@proyecto-viviana/solid-stately 0.5.1 → 0.6.0-rc.0

package/dist/index.js

@@ -1,8 +1,672 @@
-import { createComputed, createContext, createEffect, createMemo, createSignal, createUniqueId, on, onCleanup, untrack, useContext } from "solid-js";
-import { isServer as isServer$1 } from "solid-js/web";
+/*
+* Copyright 2024 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/autocomplete/useAutocompleteState.ts
+/*
+* Copyright 2026 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/datepicker/IncompleteDate.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/calendar/useCalendarState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/datepicker/useDateFieldState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/datepicker/utils.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/datepicker/useDatePickerState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/calendar/useCalendarState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/calendar/useRangeCalendarState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/calendar/utils.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the 'License');
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/datepicker/useTimeFieldState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/checkbox/useCheckboxGroupState.ts
+/*
+* Copyright 2024 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/collections/BaseCollection.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/list/ListCollection.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/list/useListState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/list/useSingleSelectListState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/menu/useMenuTriggerState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/SelectionManager.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/useMultipleSelectionState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/collections/getChildNodes.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/collections/getItemCount.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/color/Color.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/color/useColorAreaState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/color/useColorChannelFieldState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/color/useColorFieldState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/color/useColorSliderState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/color/useColorWheelState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/combobox/useComboBoxState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/data/useAsyncList.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/data/useListData.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/data/useListData.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/data/useTreeData.ts
+/*
+* Copyright 2024 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/disclosure/useDisclosureGroupState.ts
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/disclosure/useDisclosureState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/dnd/useDrag.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/dnd/useDraggableCollectionState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/dnd/useDrop.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/dnd/useDroppableCollectionState.ts
+/*
+* Copyright 2023 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/form/useFormValidationState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/numberfield/useNumberFieldState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/overlays/useOverlayTriggerState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/radio/useRadioGroupState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/searchfield/useSearchFieldState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/select/useSelectState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/Selection.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/SelectionManager.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/selection/useMultipleSelectionState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/slider/useSliderState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/ssr/SSRProvider.tsx
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-aria/src/utils/useId.ts
+/*
+* Copyright 2023 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/steplist/useStepListState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/TableCollection.ts
+/*
+* Copyright 2022 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/useTableColumnResizeState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/useTableState.ts
+/*
+* Copyright 2023 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/table/useTreeGridState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tabs/useTabListState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/utils/useControlledState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/toast/useToastState.ts
+/*
+* Copyright 2024 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/toggle/useToggleGroupState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/toggle/useToggleState.ts
+/*
+* Copyright 2026 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tokenfield/TokenFieldValue.ts
+/*
+* Copyright 2026 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tokenfield/useTokenFieldState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tooltip/useTooltipTriggerState.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tree/TreeCollection.ts
+/*
+* Copyright 2020 Adobe. All rights reserved.
+* This file is licensed to you under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License. You may obtain a copy
+* of the License at http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software distributed under
+* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+* OF ANY KIND, either express or implied. See the License for the specific language
+* governing permissions and limitations under the License.
+*/
+// Ported to SolidJS for Proyecto Viviana; based on packages/react-stately/src/tree/useTreeState.ts
+import { createContext, createEffect, createMemo, createSignal, createUniqueId, flush, getObserver, getOwner, onCleanup, untrack, useContext } from "solid-js";
+import { isServer as isServer$1 } from "@solidjs/web";
 import { CalendarDate, CalendarDate as CalendarDateClass, CalendarDateTime as CalendarDateTimeClass, DateFormatter, DateFormatter as DateFormatter$1, GregorianCalendar, GregorianCalendar as GregorianCalendar$1, Time, Time as TimeClass, ZonedDateTime as ZonedDateTimeClass, createCalendar, createCalendar as createCalendar$1, endOfMonth, endOfMonth as endOfMonth$1, endOfWeek, endOfYear, getDayOfWeek, getLocalTimeZone, getLocalTimeZone as getLocalTimeZone$1, getWeeksInMonth, getWeeksInMonth as getWeeksInMonth$1, isEqualCalendar, isSameDay, isSameDay as isSameDay$1, isSameMonth, isSameMonth as isSameMonth$1, isSameYear, isToday, isWeekend, maxDate, maxDate as maxDate$1, minDate, minDate as minDate$1, now, now as now$1, parseAbsolute, parseAbsoluteToLocal, parseDate, parseDateTime, parseTime, parseZonedDateTime, startOfMonth, startOfMonth as startOfMonth$1, startOfWeek, startOfWeek as startOfWeek$1, startOfYear, toCalendar, toCalendar as toCalendar$1, toCalendarDate, toCalendarDate as toCalendarDate$1, toCalendarDateTime, toCalendarDateTime as toCalendarDateTime$1, toTime, toTime as toTime$1, toZoned, toZoned as toZoned$1, today, today as today$1 } from "@internationalized/date";
+import { NumberFormatter, NumberParser } from "@internationalized/number";
 //#region src/utils/reactivity.ts
 /**
+* Reactivity utilities for Solid Stately
+*
+* Provides type-safe utilities for working with SolidJS reactivity patterns.
+*/
+/**
 * Unwraps a MaybeAccessor to get the underlying value.
 * If the input is a function, it calls it to get the value.
 * Otherwise, it returns the value directly.
@@ -18,15 +682,60 @@ function access(value) {
 function isAccessor(value) {
 	return typeof value === "function";
 }
-//#endregion
-//#region src/toggle/createToggleState.ts
 /**
-* Toggle state for Solid Stately
+* Headless state is written from factory setup and from public setters that
+* tests (and some call sites) invoke inside `createRoot` / a component body.
+* Solid 2 throws on those writes unless the signal opts into `ownedWrite`.
 *
-* Provides state management for toggle components like checkboxes and switches.
-*
-* This is a 1:1 port of @react-stately/toggle's useToggleState.
+* Solid 2 also hides unflushed writes from both default reads (unowned /
+* committed snapshot) and `latest()` (A28: flush first to read your own
+* write). Headless methods chain read-then-write in the same turn, so the
+* getter returns a live mirror and still reads the signal for tracking.
+*/
+function createInternalSignal(value, options) {
+	let live = value;
+	const [get, set] = createSignal(value, {
+		...options,
+		ownedWrite: true
+	});
+	const read = (() => {
+		if (getObserver()) get();
+		return live;
+	});
+	const write = ((next) => {
+		const resolved = typeof next === "function" ? next(live) : next;
+		live = resolved;
+		set(resolved);
+		return resolved;
+	});
+	return [read, write];
+}
+/**
+* Same-turn read of a headless accessor. `createInternalSignal` getters
+* already return the live mirror; this is for call sites that used to wrap
+* `latest()` (which does not see unflushed writes in Solid 2 rc.9).
 */
+function readNow(accessor) {
+	return accessor();
+}
+//#endregion
+//#region src/utils/owner.ts
+/**
+* Solid 2 owner guards. `useContext` throws when there is no reactive root,
+* even if the context has a default — hook factories (and tests) call
+* `createFormValidationState` outside a component.
+*/
+/** Read context, or the context default, when called with no owner. */
+function useContextOptional(context) {
+	if (!getOwner()) return context.defaultValue;
+	try {
+		return useContext(context);
+	} catch {
+		return context.defaultValue;
+	}
+}
+//#endregion
+//#region src/toggle/createToggleState.ts
 /**
 * Provides state management for toggle components like checkboxes and switches.
 */
@@ -34,7 +743,7 @@ function createToggleState(props = {}) {
 	const getProps = () => access(props);
 	const initialProps = getProps();
 	const initialSelected = initialProps.isSelected ?? initialProps.defaultSelected ?? false;
-	const [internalSelected, setInternalSelected] = createSignal(initialSelected);
+	const [internalSelected, setInternalSelected] = createInternalSignal(initialSelected);
 	const isControlled = () => getProps().isSelected !== void 0;
 	const isSelected = () => {
 		const p = getProps();
@@ -47,8 +756,9 @@ function createToggleState(props = {}) {
 		p.onChange?.(value);
 	}
 	function toggle() {
-		if (getProps().isReadOnly) return;
-		setSelected(!isSelected());
+		const p = getProps();
+		if (p.isReadOnly) return;
+		setSelected(!(isControlled() ? p.isSelected ?? false : readNow(internalSelected)));
 	}
 	return {
 		isSelected,
@@ -59,14 +769,6 @@ function createToggleState(props = {}) {
 }
 //#endregion
 //#region src/toggle/createToggleGroupState.ts
-/**
-* Toggle group state for Solid Stately
-*
-* Provides state management for groups of toggle buttons with
-* single or multiple selection.
-*
-* This is a port of @react-stately/toggle's useToggleGroupState.
-*/
 function toKeySet(keys) {
 	return new Set(keys ? Array.from(keys) : []);
 }
@@ -75,7 +777,7 @@ function toKeySet(keys) {
 */
 function createToggleGroupState(props = {}) {
 	const getProps = () => access(props);
-	const [internalSelectedKeys, setInternalSelectedKeys] = createSignal(toKeySet(getProps().defaultSelectedKeys));
+	const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal(toKeySet(getProps().defaultSelectedKeys));
 	const isControlled = () => getProps().selectedKeys !== void 0;
 	const selectedKeys = () => isControlled() ? toKeySet(getProps().selectedKeys) : internalSelectedKeys();
 	function setSelectedKeys(keys) {
@@ -87,7 +789,7 @@ function createToggleGroupState(props = {}) {
 		const props = getProps();
 		const mode = props.selectionMode ?? "single";
 		const disallowEmptySelection = props.disallowEmptySelection ?? false;
-		const currentKeys = selectedKeys();
+		const currentKeys = isControlled() ? toKeySet(props.selectedKeys) : readNow(internalSelectedKeys);
 		let nextKeys;
 		if (mode === "multiple") {
 			nextKeys = new Set(currentKeys);
@@ -107,7 +809,7 @@ function createToggleGroupState(props = {}) {
 			return getProps().isDisabled ?? false;
 		},
 		get selectedKeys() {
-			return new Set(selectedKeys());
+			return new Set(isControlled() ? selectedKeys() : readNow(internalSelectedKeys));
 		},
 		toggleKey,
 		setSelected,
@@ -117,11 +819,6 @@ function createToggleGroupState(props = {}) {
 //#endregion
 //#region src/autocomplete/createAutocompleteState.ts
 /**
-* createAutocompleteState - State management for autocomplete components
-*
-* Based on @react-stately/autocomplete useAutocompleteState.
-*/
-/**
 * Provides state management for an autocomplete component.
 *
 * @example
@@ -143,9 +840,9 @@ function createToggleGroupState(props = {}) {
 */
 function createAutocompleteState(props = {}) {
 	const getProps = () => access(props);
-	const [focusedNodeId, setFocusedNodeId] = createSignal(null);
+	const [focusedNodeId, setFocusedNodeId] = createInternalSignal(null);
 	const isControlled = () => getProps().inputValue !== void 0;
-	const [uncontrolledValue, setUncontrolledValue] = createSignal(getProps().defaultInputValue ?? "");
+	const [uncontrolledValue, setUncontrolledValue] = createInternalSignal(getProps().defaultInputValue ?? "");
 	const inputValue = () => {
 		const p = getProps();
 		return isControlled() ? p.inputValue ?? "" : uncontrolledValue();
@@ -165,21 +862,13 @@ function createAutocompleteState(props = {}) {
 //#endregion
 //#region src/textfield/createTextFieldState.ts
 /**
-* TextField state for Solid Stately
-*
-* Provides state management for text input components.
-*
-* This is a port of @react-stately/utils's useControlledState pattern
-* as used by @react-aria/textfield.
-*/
-/**
 * Provides state management for text input components.
 * Supports both controlled and uncontrolled modes.
 */
 function createTextFieldState(props = {}) {
 	const getProps = () => access(props);
 	const initialProps = getProps();
-	const [internalValue, setInternalValue] = createSignal(initialProps.value ?? initialProps.defaultValue ?? "");
+	const [internalValue, setInternalValue] = createInternalSignal(initialProps.value ?? initialProps.defaultValue ?? "");
 	const isControlled = () => getProps().value !== void 0;
 	const value = () => {
 		const p = getProps();
@@ -196,6 +885,297 @@ function createTextFieldState(props = {}) {
 	};
 }
 //#endregion
+//#region src/tokenfield/TokenFieldValue.ts
+var Direction = /* @__PURE__ */ function(Direction) {
+	Direction[Direction["Forward"] = 1] = "Forward";
+	Direction[Direction["Backward"] = -1] = "Backward";
+	return Direction;
+}(Direction || {});
+/**
+* A list of segments containing editable text and non-editable tokens.
+*/
+var TokenFieldValue = class {
+	static Direction = Direction;
+	/** The text and token segments in the list. */
+	segments;
+	/** The caret position. */
+	caretPosition = {
+		index: 0,
+		offset: 0
+	};
+	previous = null;
+	next = null;
+	isCoalescing = true;
+	/** Create a new list with the given segments. */
+	constructor(tokens, options) {
+		this.segments = tokens;
+		this.caretPosition = options?.caretPosition ?? {
+			index: 0,
+			offset: 0
+		};
+	}
+	createFieldValue(segments) {
+		const Constructor = this.constructor;
+		return new Constructor(segments);
+	}
+	/** Create a new list with the caret position set to the given position. */
+	withCaretPosition(caretPosition) {
+		if (this.caretPosition.index === caretPosition.index && this.caretPosition.offset === caretPosition.offset) return this;
+		let result = this.createFieldValue(this.segments);
+		result.caretPosition = caretPosition;
+		result.previous = this.previous;
+		result.next = this.next;
+		result.isCoalescing = this.isCoalescing;
+		return result;
+	}
+	splitSegment(segment, offset) {
+		if (!segment) {
+			let empty = this.createTextSegment("");
+			return [offset > 0 ? empty : null, offset > 0 ? null : empty];
+		}
+		if (segment.type === "token") return [offset > 0 ? { ...segment } : null, offset > 0 ? null : { ...segment }];
+		return [offset > 0 ? {
+			type: "text",
+			text: segment.text.slice(0, offset)
+		} : null, offset < segment.text.length ? this.createTextSegment(segment.text.slice(offset)) : null];
+	}
+	createTextSegment(text) {
+		return {
+			type: "text",
+			text
+		};
+	}
+	tokenize(text) {
+		return [this.createTextSegment(text)];
+	}
+	clampPosition(position) {
+		if (this.segments.length > 0 && position.index >= this.segments.length) return {
+			index: this.segments.length - 1,
+			offset: this.segments[this.segments.length - 1].text.length
+		};
+		if (position.index < 0) return {
+			index: 0,
+			offset: 0
+		};
+		return position;
+	}
+	/** Replace the text between two positions with new text. */
+	replaceRange(start, end, text, coalesce = true) {
+		return this.replaceRangeWithSegments(start, end, text.length > 0 ? [this.createTextSegment(text)] : [], coalesce);
+	}
+	/** Replace the text between two positions with new segments. */
+	replaceRangeWithSegments(start, end, insert, coalesce = true) {
+		start = this.clampPosition(start);
+		end = this.clampPosition(end);
+		let startSegment = this.segments[start.index];
+		let endSegment = this.segments[end.index];
+		let [startSplit] = this.splitSegment(startSegment, start.offset);
+		let [, endSplit] = this.splitSegment(endSegment, end.offset);
+		let newSegments = this.segments.slice(0, start.index);
+		if (startSplit) appendSegments(newSegments, [startSplit]);
+		if (insert.length) appendSegments(newSegments, insert, (text) => this.tokenize(text));
+		let lastSegment = newSegments[newSegments.length - 1];
+		let lastIsText = lastSegment && lastSegment.type === "text";
+		let caret = {
+			index: lastIsText ? newSegments.length - 1 : newSegments.length,
+			offset: lastIsText ? lastSegment.text.length : 0
+		};
+		if (endSplit) appendSegments(newSegments, [endSplit]);
+		appendSegments(newSegments, this.segments.slice(end.index + 1));
+		let segments = this.createFieldValue(newSegments);
+		segments.caretPosition = caret;
+		segments.isCoalescing = coalesce;
+		if (this.isCoalescing && coalesce && this.previous) {
+			segments.previous = this.previous;
+			segments.previous.next = segments;
+		} else {
+			segments.previous = this;
+			this.caretPosition = end;
+			this.next = segments;
+		}
+		return segments;
+	}
+	/** Find the boundary before or after a position using an Intl.Segmenter. */
+	findBoundaryWithSegmenter(position, segmenter, direction) {
+		position = this.clampPosition(position);
+		for (let i = position.index; i >= 0 && i < this.segments.length; i += direction) {
+			let segment = this.segments[i];
+			switch (segment.type) {
+				case "token":
+					if (i !== position.index || (direction === -1 ? position.offset > 0 : position.offset === 0)) {
+						let index = i + direction;
+						return {
+							index: index >= 0 ? index : 0,
+							offset: direction === -1 && index >= 0 ? this.segments[index].text.length : 0
+						};
+					}
+					continue;
+				case "text": {
+					let offset = direction === -1 ? segment.text.length : 0;
+					if (i === position.index) offset = position.offset;
+					if (direction === -1) offset--;
+					if (offset < 0 || offset >= segment.text.length) continue;
+					let part = segmenter.segment(segment.text).containing(offset);
+					while (part && part.isWordLike === false) {
+						offset += direction;
+						part = segmenter.segment(segment.text).containing(offset);
+					}
+					if (part) return {
+						index: i,
+						offset: direction === -1 ? part.index : part.index + part.segment.length
+					};
+					continue;
+				}
+			}
+		}
+		return null;
+	}
+	/** Find a line boundary before or after a position. */
+	findLineBoundary(position, direction) {
+		let res = this.findText(position, direction, "\n");
+		if (res) return res;
+		return direction === -1 ? {
+			index: 0,
+			offset: 0
+		} : {
+			index: this.segments.length - 1,
+			offset: this.segments[this.segments.length - 1].text.length
+		};
+	}
+	/** Find a string or regular expression match before or after a position. */
+	findText(position, direction, search) {
+		if (this.segments.length === 0) return null;
+		for (let i = position.index; i >= 0 && i < this.segments.length; i += direction) {
+			let segment = this.segments[i];
+			if (segment.type !== "text") continue;
+			let offset = findInText(segment.text, search, direction, i === position.index ? position.offset : void 0);
+			if (offset >= 0) return {
+				index: i,
+				offset
+			};
+		}
+		return null;
+	}
+	/** Delete text at a position using a segmenter. */
+	delete(position, segmenter, direction, coalesce = true) {
+		let boundary = this.findBoundaryWithSegmenter(position, segmenter, direction);
+		if (boundary) return this.replaceRange(direction === -1 ? boundary : position, direction === -1 ? position : boundary, "", coalesce);
+		this.caretPosition = position;
+		return this;
+	}
+	/** Delete text to the next or previous line break. */
+	deleteLine(position, direction, coalesce = true) {
+		if (this.segments.length === 0) return this;
+		let boundary = this.findLineBoundary(position, direction);
+		if (boundary) return this.replaceRange(direction === -1 ? boundary : position, direction === -1 ? position : boundary, "", coalesce);
+		return this;
+	}
+	/** Create a new list containing a subset of the segments. */
+	slice(start, end) {
+		start = this.clampPosition(start);
+		end = this.clampPosition(end);
+		if (start.index === end.index && start.offset === end.offset) return this.createFieldValue([]);
+		if (start.index === end.index) {
+			let segment = this.segments[start.index];
+			if (segment.type === "text") return this.createFieldValue([{
+				type: "text",
+				text: segment.text.slice(start.offset, end.offset)
+			}]);
+			return this.createFieldValue([segment]);
+		}
+		let startSegment = this.segments[start.index];
+		let endSegment = this.segments[end.index];
+		let [, startSplit] = this.splitSegment(startSegment, start.offset);
+		let [endSplit] = this.splitSegment(endSegment, end.offset);
+		let result = [];
+		if (startSplit) result.push(startSplit);
+		result.push(...this.segments.slice(start.index + 1, end.index));
+		if (endSplit) result.push(endSplit);
+		return this.createFieldValue(result);
+	}
+	/** Convert the list to a string. */
+	toString() {
+		return this.segments.map((seg) => seg.text).join("");
+	}
+	/** Returns the previous list in the undo history. */
+	undo() {
+		return this.previous ?? this;
+	}
+	/** Returns the next list in the redo history. */
+	redo() {
+		return this.next ?? this;
+	}
+	/** End coalescing undo/redo history. */
+	endCoalescing() {
+		this.isCoalescing = false;
+	}
+};
+function findInText(text, search, direction, fromOffset) {
+	if (typeof search === "string") {
+		if (direction === -1) return text.lastIndexOf(search, fromOffset !== void 0 ? fromOffset - 1 : text.length - 1);
+		return text.indexOf(search, fromOffset ?? 0);
+	}
+	if (direction === 1) {
+		let start = fromOffset ?? 0;
+		let index = text.slice(start).search(search);
+		return index >= 0 ? start + index : -1;
+	}
+	let limit = fromOffset !== void 0 ? fromOffset : text.length;
+	if (limit < 0) return -1;
+	let re = search.flags.includes("g") ? search : new RegExp(search.source, search.flags + "g");
+	return Array.from(text.slice(0, limit).matchAll(re)).at(-1)?.index ?? -1;
+}
+function appendSegments(segments, insert, tokenize) {
+	for (let segment of insert) {
+		if (segment.type === "text" && segment.text.length === 0) continue;
+		let last = segments[segments.length - 1];
+		if (last && last.type === "text" && segment.type === "text") {
+			if (tokenize) {
+				let tokenized = tokenize(last.text + segment.text);
+				segments.splice(segments.length - 1, 1, ...tokenized);
+			} else segments[segments.length - 1] = {
+				type: "text",
+				text: last.text + segment.text
+			};
+		} else if (tokenize && segment.type === "text") {
+			let tokenized = tokenize(segment.text);
+			segments.push(...tokenized);
+		} else segments.push(segment);
+	}
+	return segments;
+}
+//#endregion
+//#region src/tokenfield/createTokenFieldState.ts
+/**
+* Provides state management for a token field. Tracks the field value and the
+* composition state.
+*/
+function createTokenFieldState(props = {}) {
+	const getProps = () => access(props);
+	const initialProps = getProps();
+	const initialValue = initialProps.value ?? initialProps.defaultValue ?? new TokenFieldValue([]);
+	const [internalValue, setInternalValue] = createInternalSignal(initialValue);
+	const [isComposing, setComposing] = createInternalSignal(false);
+	const isControlled = () => getProps().value !== void 0;
+	const value = () => {
+		const p = getProps();
+		return isControlled() ? p.value ?? initialValue : internalValue();
+	};
+	function setValue(fn) {
+		const p = getProps();
+		const current = value();
+		const next = typeof fn === "function" ? fn(current) : fn;
+		if (!isControlled()) setInternalValue(() => next);
+		p.onChange?.(next);
+	}
+	return {
+		value,
+		setValue,
+		isComposing,
+		setComposing
+	};
+}
+//#endregion
 //#region src/form/createFormValidationState.ts
 /**
 * createFormValidationState for solid-stately
@@ -285,39 +1265,45 @@ function createFormValidationState(props) {
 		validationErrors: [],
 		validationDetails: CUSTOM_VALIDITY_STATE
 	} : null);
-	const clientError = createMemo(() => {
+	const computeClientError = () => {
 		const validate = props.validate;
 		if (!validate || props.value == null) return null;
 		return getValidationResult$1(runValidate(validate, props.value));
-	});
+	};
+	const clientError = createMemo(computeClientError);
 	const builtinValidation = createMemo(() => {
 		const builtinValidationProp = props.builtinValidation;
 		if (builtinValidationProp?.validationDetails.valid) return;
 		return builtinValidationProp;
 	});
-	const serverErrors = useContext(FormValidationContext);
+	const serverErrors = useContextOptional(FormValidationContext) ?? {};
 	const serverErrorMessages = createMemo(() => {
 		const name = props.name;
 		if (name) return Array.isArray(name) ? name.flatMap((n) => asArray(serverErrors[n])) : asArray(serverErrors[name]);
 		return [];
 	});
-	const [lastServerErrors, setLastServerErrors] = createSignal(serverErrors);
-	const [isServerErrorCleared, setServerErrorCleared] = createSignal(false);
-	createEffect(() => {
-		if (serverErrors !== lastServerErrors()) {
-			setLastServerErrors(serverErrors);
+	const [lastServerErrors, setLastServerErrors] = createInternalSignal(serverErrors);
+	const [isServerErrorCleared, setServerErrorCleared] = createInternalSignal(false);
+	createEffect(() => ({
+		errors: serverErrors,
+		last: lastServerErrors()
+	}), ({ errors, last }) => {
+		if (errors !== last) {
+			setLastServerErrors(errors);
 			setServerErrorCleared(false);
 		}
 	});
 	const serverError = createMemo(() => getValidationResult$1(isServerErrorCleared() ? [] : serverErrorMessages()));
-	const [currentValidity, setCurrentValidity] = createSignal(DEFAULT_VALIDATION_RESULT);
-	const [commitQueued, setCommitQueued] = createSignal(false);
+	const [currentValidity, setCurrentValidity] = createInternalSignal(DEFAULT_VALIDATION_RESULT);
+	const [commitQueued, setCommitQueued] = createInternalSignal(false);
 	let nextValidation = DEFAULT_VALIDATION_RESULT;
 	let lastError = DEFAULT_VALIDATION_RESULT;
-	createEffect(() => {
-		if (!commitQueued()) return;
+	createEffect(() => ({
+		queued: commitQueued(),
+		error: clientError() || builtinValidation() || nextValidation
+	}), ({ queued, error }) => {
+		if (!queued) return;
 		setCommitQueued(false);
-		const error = clientError() || builtinValidation() || nextValidation;
 		if (!isEqualValidation(error, lastError)) {
 			lastError = error;
 			setCurrentValidity(error);
@@ -344,7 +1330,7 @@ function createFormValidationState(props) {
 		},
 		commitValidation() {
 			if (validationBehavior() === "native") {
-				const error = clientError() || builtinValidation() || nextValidation;
+				const error = computeClientError() || builtinValidation() || nextValidation;
 				if (!isEqualValidation(error, lastError)) {
 					lastError = error;
 					setCurrentValidity(error);
@@ -395,13 +1381,14 @@ function createCheckboxGroupState(props = {}) {
 	const getProps = () => access(props);
 	const initialProps = getProps();
 	const initialValue = initialProps.value ?? initialProps.defaultValue ?? [];
-	const [internalValue, setInternalValue] = createSignal(initialValue);
+	const [internalValue, setInternalValue] = createInternalSignal(initialValue);
 	const controlledValue = createMemo(() => getProps().value);
 	const isControlled = () => controlledValue() !== void 0;
 	const value = () => {
 		const controlled = controlledValue();
 		return controlled !== void 0 ? controlled : internalValue();
 	};
+	const liveValue = () => isControlled() ? value() : readNow(internalValue);
 	const isRequired = () => {
 		return !!getProps().isRequired && value().length === 0;
 	};
@@ -437,21 +1424,21 @@ function createCheckboxGroupState(props = {}) {
 	function addValue(addVal) {
 		const p = getProps();
 		if (p.isReadOnly || p.isDisabled) return;
-		const current = value();
-		if (!current.includes(addVal)) setValue([...current, addVal]);
+		const snapshot = liveValue();
+		if (!snapshot.includes(addVal)) setValue([...snapshot, addVal]);
 	}
 	function removeValue(removeVal) {
 		const p = getProps();
 		if (p.isReadOnly || p.isDisabled) return;
-		const current = value();
-		if (current.includes(removeVal)) setValue(current.filter((v) => v !== removeVal));
+		const snapshot = liveValue();
+		if (snapshot.includes(removeVal)) setValue(snapshot.filter((v) => v !== removeVal));
 	}
 	function toggleValue(toggleVal) {
 		const p = getProps();
 		if (p.isReadOnly || p.isDisabled) return;
-		const current = value();
-		if (current.includes(toggleVal)) setValue(current.filter((v) => v !== toggleVal));
-		else setValue([...current, toggleVal]);
+		const snapshot = liveValue();
+		if (snapshot.includes(toggleVal)) setValue(snapshot.filter((v) => v !== toggleVal));
+		else setValue([...snapshot, toggleVal]);
 	}
 	return {
 		value,
@@ -484,10 +1471,14 @@ function createCheckboxGroupState(props = {}) {
 * SSR utilities for Solid Stately
 *
 * SolidJS has built-in SSR support with `isServer` and `createUniqueId()`.
-* These utilities provide a consistent API matching React-Stately's patterns.
+* These utilities provide a consistent port of the upstream SSR API.
+*
+* Ported from:
+* - packages/react-aria/src/ssr/SSRProvider.tsx
+* - packages/react-aria/src/utils/useId.ts
 */
 /**
-* Re-export isServer from solid-js/web for convenience.
+* Re-export isServer from @solidjs/web for convenience.
 */
 const isServer = isServer$1;
 /**
@@ -504,8 +1495,9 @@ function createIsSSR() {
 * @param defaultId - Optional default ID to use instead of generating one.
 */
 function createId(defaultId) {
+	const uniqueId = createUniqueId();
 	if (defaultId) return defaultId;
-	return `solid-stately-${createUniqueId()}`;
+	return `solid-stately-${uniqueId}`;
 }
 /**
 * Check if we can use DOM APIs.
@@ -539,9 +1531,9 @@ function createRadioGroupState(props = {}) {
 	const getProps = () => access(props);
 	const initialProps = untrack(() => getProps());
 	const name = initialProps.name || `radio-group-${createId()}`;
-	const [internalValue, setInternalValue] = createSignal(initialProps.defaultValue ?? null);
-	const [lastFocusedValue, setLastFocusedValueInternal] = createSignal(null);
-	const [syncVersion, setSyncVersion] = createSignal(0);
+	const [internalValue, setInternalValue] = createInternalSignal(initialProps.defaultValue ?? null);
+	const [lastFocusedValue, setLastFocusedValueInternal] = createInternalSignal(null);
+	const [syncVersion, setSyncVersion] = createInternalSignal(0);
 	const controlledValue = createMemo(() => {
 		const value = getProps().value;
 		return value === void 0 ? void 0 : value ?? null;
@@ -614,16 +1606,13 @@ function createRadioGroupState(props = {}) {
 //#endregion
 //#region src/overlays/createOverlayTriggerState.ts
 /**
-* Manages state for an overlay trigger.
-* Based on @react-stately/overlays useOverlayTriggerState.
-*/
-/**
 * Manages state for an overlay trigger. Tracks whether the overlay is open, and provides
 * methods to toggle this state.
 */
 function createOverlayTriggerState(props = {}) {
 	const propsAccessor = () => access(props);
-	const [internalOpen, setInternalOpen] = createSignal(propsAccessor().defaultOpen ?? false);
+	const [internalOpen, setInternalOpen] = createInternalSignal(propsAccessor().defaultOpen ?? false);
+	const [point, setPoint] = createInternalSignal(null);
 	const isOpen = () => {
 		const p = propsAccessor();
 		return p.isOpen !== void 0 ? p.isOpen : internalOpen();
@@ -635,13 +1624,19 @@ function createOverlayTriggerState(props = {}) {
 	};
 	const open = () => setOpen(true);
 	const close = () => setOpen(false);
-	const toggle = () => setOpen(!isOpen());
+	const toggle = () => {
+		const p = propsAccessor();
+		const open = p.isOpen !== void 0 ? p.isOpen : readNow(internalOpen);
+		setOpen(!open);
+	};
 	return {
 		isOpen,
 		setOpen,
 		open,
 		close,
-		toggle
+		toggle,
+		point,
+		setPoint
 	};
 }
 //#endregion
@@ -784,8 +1779,8 @@ function getNthItem(iterable, index) {
 const itemCountCache = /* @__PURE__ */ new WeakMap();
 /**
 * Counts the item nodes (recursing into sections, ignoring section headers and
-* other non-item nodes) in a collection. Faithful port of
-* @react-stately/collections `getItemCount`; used by createOption to populate
+* other non-item nodes) in a collection. Ported from
+* packages/react-stately/src/collections/getItemCount.ts; used by createOption to populate
 * `aria-setsize` when the listbox is virtualized. Cached per (immutable)
 * collection identity, exactly like upstream.
 */
@@ -828,16 +1823,18 @@ function getAncestors(collection, node) {
 //#region src/collections/createSelectionState.ts
 /**
 * Selection state management for collections.
-* Based on @react-stately/selection.
+* Ported from:
+* - packages/react-stately/src/selection/useMultipleSelectionState.ts
+* - packages/react-stately/src/selection/SelectionManager.ts
 */
 /**
 * Creates selection state for a collection.
 */
 function createSelectionState(props = {}) {
 	const getProps = () => access(props);
-	const [internalBehavior, setInternalBehavior] = createSignal("toggle");
-	const [internalSelectedKeys, setInternalSelectedKeys] = createSignal(getInitialSelection$2(getProps().defaultSelectedKeys));
-	const [anchorKey, setAnchorKey] = createSignal(null);
+	const [internalBehavior, setInternalBehavior] = createInternalSignal("toggle");
+	const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal(getInitialSelection$2(getProps().defaultSelectedKeys));
+	const [anchorKey, setAnchorKey] = createInternalSignal(null);
 	const selectionMode = () => getProps().selectionMode ?? "none";
 	const selectionBehavior = () => {
 		return getProps().selectionBehavior ?? internalBehavior();
@@ -845,11 +1842,11 @@ function createSelectionState(props = {}) {
 	const disallowEmptySelection = () => {
 		return getProps().disallowEmptySelection ?? false;
 	};
-	const selectedKeys = createMemo(() => {
+	const selectedKeys = () => {
 		const p = getProps();
 		if (p.selectedKeys !== void 0) return normalizeSelection$2(p.selectedKeys);
 		return internalSelectedKeys();
-	});
+	};
 	const disabledKeys = createMemo(() => {
 		const keys = getProps().disabledKeys;
 		return keys ? new Set(keys) : /* @__PURE__ */ new Set();
@@ -864,8 +1861,9 @@ function createSelectionState(props = {}) {
 	const isSelectAll = () => {
 		return selectedKeys() === "all";
 	};
+	const liveSelectedKeys = () => getProps().selectedKeys !== void 0 ? selectedKeys() : readNow(internalSelectedKeys);
 	const isSelected = (key) => {
-		const keys = selectedKeys();
+		const keys = liveSelectedKeys();
 		if (keys === "all") return true;
 		return keys.has(key);
 	};
@@ -878,7 +1876,7 @@ function createSelectionState(props = {}) {
 			p.onSelectionChange?.(newSelection);
 			return;
 		}
-		const current = internalSelectedKeys();
+		const current = readNow(internalSelectedKeys);
 		if (current === "all" || newSelection === "all" || current.size !== newSelection.size || ![...current].every((k) => newSelection.has(k)) || p.allowDuplicateSelectionEvents) {
 			setInternalSelectedKeys(newSelection);
 			p.onSelectionChange?.(newSelection);
@@ -887,10 +1885,10 @@ function createSelectionState(props = {}) {
 	const toggleSelection = (key) => {
 		if (isDisabled(key)) return;
 		if (selectionMode() === "none") return;
-		const current = selectedKeys();
+		const current = liveSelectedKeys();
 		if (selectionMode() === "single") {
 			if (isSelected(key) && !disallowEmptySelection()) updateSelection(/* @__PURE__ */ new Set());
-			else updateSelection(new Set([key]));
+			else updateSelection(/* @__PURE__ */ new Set([key]));
 			return;
 		}
 		if (current === "all") return;
@@ -904,7 +1902,7 @@ function createSelectionState(props = {}) {
 	const replaceSelection = (key) => {
 		if (isDisabled(key)) return;
 		if (selectionMode() === "none") return;
-		updateSelection(new Set([key]));
+		updateSelection(/* @__PURE__ */ new Set([key]));
 		setAnchorKey(key);
 	};
 	const setSelectedKeys = (keys) => {
@@ -949,9 +1947,10 @@ function createSelectionState(props = {}) {
 	};
 	const select = (key, e) => {
 		if (selectionMode() === "none") return;
-		if (selectionMode() === "single") if (isSelected(key) && !disallowEmptySelection()) toggleSelection(key);
-		else replaceSelection(key);
-		else if (selectionBehavior() === "toggle" || e != null && (e.pointerType === "touch" || e.pointerType === "virtual")) toggleSelection(key);
+		if (selectionMode() === "single") {
+			if (isSelected(key) && !disallowEmptySelection()) toggleSelection(key);
+			else replaceSelection(key);
+		} else if (selectionBehavior() === "toggle" || e != null && (e.pointerType === "touch" || e.pointerType === "virtual")) toggleSelection(key);
 		else replaceSelection(key);
 	};
 	const setSelectionBehavior = (behavior) => {
@@ -1013,13 +2012,11 @@ var Selection = class Selection extends Set {
 * Raw multiple-selection + focus state for a collection.
 *
 * The lower of the two selection layers ported from upstream
-* (`@react-stately/selection`'s `useMultipleSelectionState`): it owns the
+* (`packages/react-stately/src/selection/useMultipleSelectionState.ts`): it owns the
 * selected keys, focus, selection behavior, and disabled keys, but is NOT
 * collection-aware. The collection-aware operations (toggle, extend, select
 * all, range, etc.) live in {@link SelectionManager}, which is built on top of
 * this state.
-*
-* Based on @react-stately/selection.
 */
 function equalSets(setA, setB) {
 	if (setA.size !== setB.size) return false;
@@ -1035,24 +2032,25 @@ function convertSelection(selection, defaultValue) {
 */
 function createMultipleSelectionState(props = {}) {
 	const getProps = () => access(props);
-	const [isFocused, setIsFocused] = createSignal(false);
-	const [focusedKey, setFocusedKeySignal] = createSignal(null);
-	const [childFocusStrategy, setChildFocusStrategy] = createSignal(null);
-	const [uncontrolledSelectedKeys, setUncontrolledSelectedKeys] = createSignal(convertSelection(getProps().defaultSelectedKeys, new Selection()));
+	const [isFocused, setIsFocused] = createInternalSignal(false);
+	const [focusedKey, setFocusedKeySignal] = createInternalSignal(null);
+	const [childFocusStrategy, setChildFocusStrategy] = createInternalSignal(null);
+	const [uncontrolledSelectedKeys, setUncontrolledSelectedKeys] = createInternalSignal(convertSelection(getProps().defaultSelectedKeys, new Selection()));
 	const selectedKeys = createMemo(() => {
 		const p = getProps();
 		if (p.selectedKeys !== void 0) return convertSelection(p.selectedKeys, new Selection());
 		return uncontrolledSelectedKeys();
 	});
 	const selectionBehaviorProp = () => getProps().selectionBehavior ?? "toggle";
-	const [selectionBehavior, setSelectionBehaviorState] = createSignal(selectionBehaviorProp());
-	createComputed(() => {
-		const keys = selectedKeys();
-		if (selectionBehaviorProp() === "replace" && untrack(selectionBehavior) === "toggle" && typeof keys === "object" && keys.size === 0) setSelectionBehaviorState("replace");
+	const [selectionBehavior, setSelectionBehaviorState] = createInternalSignal(selectionBehaviorProp());
+	createEffect(() => ({
+		keys: selectedKeys(),
+		prop: selectionBehaviorProp()
+	}), ({ keys, prop }) => {
+		if (prop === "replace" && selectionBehavior() === "toggle" && typeof keys === "object" && keys.size === 0) setSelectionBehaviorState("replace");
 	});
 	let lastSelectionBehavior = selectionBehaviorProp();
-	createComputed(() => {
-		const prop = selectionBehaviorProp();
+	createEffect(selectionBehaviorProp, (prop) => {
 		if (prop !== lastSelectionBehavior) {
 			setSelectionBehaviorState(prop);
 			lastSelectionBehavior = prop;
@@ -1067,9 +2065,10 @@ function createMultipleSelectionState(props = {}) {
 		lastSelectionEvent = keys;
 		getProps().onSelectionChange?.(keys);
 	};
+	const liveSelectedKeys = () => getProps().selectedKeys !== void 0 ? selectedKeys() : readNow(uncontrolledSelectedKeys);
 	const setSelectedKeys = (keys) => {
 		const p = getProps();
-		const current = selectedKeys();
+		const current = liveSelectedKeys();
 		if (!(p.allowDuplicateSelectionEvents || keys === "all" || current === "all" || !equalSets(keys, current))) return;
 		if (p.selectedKeys === void 0) setUncontrolledSelectedKeys(keys);
 		emitSelectionEvent(keys);
@@ -1109,7 +2108,7 @@ function createMultipleSelectionState(props = {}) {
 			setChildFocusStrategy(strategy);
 		},
 		get selectedKeys() {
-			return selectedKeys();
+			return liveSelectedKeys();
 		},
 		get lastSelectionEvent() {
 			return lastSelectionEvent;
@@ -1378,9 +2377,10 @@ var SelectionManager = class SelectionManager {
 	}
 	select(key, e) {
 		if (this.selectionMode === "none") return;
-		if (this.selectionMode === "single") if (this.isSelected(key) && !this.disallowEmptySelection) this.toggleSelection(key);
-		else this.replaceSelection(key);
-		else if (this.selectionBehavior === "toggle" || e && (e.pointerType === "touch" || e.pointerType === "virtual")) this.toggleSelection(key);
+		if (this.selectionMode === "single") {
+			if (this.isSelected(key) && !this.disallowEmptySelection) this.toggleSelection(key);
+			else this.replaceSelection(key);
+		} else if (this.selectionBehavior === "toggle" || e && (e.pointerType === "touch" || e.pointerType === "virtual")) this.toggleSelection(key);
 		else this.replaceSelection(key);
 	}
 	/** Returns whether the current selection is equal to the given selection. */
@@ -1437,7 +2437,9 @@ var SelectionManager = class SelectionManager {
 /**
 * State management for list-like components.
 * Combines collection and selection state.
-* Based on @react-stately/list.
+* Ported from:
+* - packages/react-stately/src/list/useListState.ts
+* - packages/react-stately/src/list/useSingleSelectListState.ts
 */
 /**
 * Creates state for a list component with selection.
@@ -1470,7 +2472,7 @@ function createListState(props) {
 		const itemDisabled = [];
 		const coll = collection();
 		for (const node of coll) if (node.isDisabled) itemDisabled.push(node.key);
-		return [...new Set([...propsDisabled, ...itemDisabled])];
+		return [.../* @__PURE__ */ new Set([...propsDisabled, ...itemDisabled])];
 	});
 	const state = createMultipleSelectionState({
 		get selectionMode() {
@@ -1548,9 +2550,8 @@ function createFilteredListState(state, filterFn) {
 	});
 	const selectionManager = state.selectionManager.withCollectionAccessor(() => collection());
 	let cachedCollection = null;
-	createEffect(() => {
-		const coll = collection();
-		const focusedKey = untrack(() => state.focusedKey());
+	createEffect(collection, (coll) => {
+		const focusedKey = state.focusedKey();
 		if (focusedKey != null && !coll.getItem(focusedKey) && cachedCollection) {
 			let key = cachedCollection.getKeyAfter(focusedKey);
 			let nextFocusedKey = null;
@@ -1573,7 +2574,7 @@ function createFilteredListState(state, filterFn) {
 					key = cachedCollection.getKeyBefore(key);
 				}
 			}
-			untrack(() => state.setFocusedKey(nextFocusedKey));
+			state.setFocusedKey(nextFocusedKey);
 		}
 		cachedCollection = coll;
 	});
@@ -1667,7 +2668,10 @@ function createSingleSelectListState(props) {
 //#region src/collections/createMenuState.ts
 /**
 * State management for menu components.
-* Based on @react-stately/menu.
+*
+* createMenuTriggerState is ported from
+* packages/react-stately/src/menu/useMenuTriggerState.ts.
+* createMenuState is a local composition of the separately attributed list state.
 */
 /**
 * Creates state for a menu component.
@@ -1727,6 +2731,27 @@ function createMenuState(props) {
 		close
 	};
 }
+/**
+* Creates state for a menu trigger. Mirrors `@react-stately/menu` `useMenuTriggerState`:
+* overlay open state plus the focus strategy passed through to `createMenu`.
+*/
+function createMenuTriggerState(props = {}) {
+	const overlay = createOverlayTriggerState(props);
+	const [focusStrategy, setFocusStrategy] = createInternalSignal(null);
+	return {
+		...overlay,
+		focusStrategy,
+		setFocusStrategy,
+		open(strategy = null) {
+			setFocusStrategy(strategy);
+			overlay.open();
+		},
+		toggle(strategy = null) {
+			setFocusStrategy(strategy);
+			overlay.toggle();
+		}
+	};
+}
 //#endregion
 //#region src/calendar/createCalendarState.ts
 /**
@@ -1755,16 +2780,16 @@ function createCalendarState(props = {}) {
 	const selectionMode = createMemo(() => access(props.selectionMode) ?? "single");
 	const resolvedOptions = createMemo(() => new DateFormatter$1(locale()).resolvedOptions());
 	const calendar = createMemo(() => (props.createCalendar ?? createCalendar$1)(resolvedOptions().calendar));
-	const visibleMonths = props.visibleMonths ?? 1;
+	const visibleMonths = createMemo(() => Math.max(1, Number(access(props.visibleMonths) ?? 1)));
 	const firstDayOfWeekName = () => props.firstDayOfWeek == null ? void 0 : dayOfWeekNames$1[props.firstDayOfWeek];
 	const toDisplayCalendarDate = (date) => toCalendar$1(toCalendarDate$3(date), calendar());
 	const selectionAlignmentOffset = () => {
 		switch (props.selectionAlignment) {
 			case "start": return 0;
-			case "end": return Math.max(visibleMonths - 1, 0);
+			case "end": return Math.max(visibleMonths() - 1, 0);
 			default: {
-				let halfDuration = Math.floor(visibleMonths / 2);
-				if (halfDuration > 0 && visibleMonths % 2 === 0) halfDuration--;
+				let halfDuration = Math.floor(visibleMonths() / 2);
+				if (halfDuration > 0 && visibleMonths() % 2 === 0) halfDuration--;
 				return halfDuration;
 			}
 		}
@@ -1775,7 +2800,7 @@ function createCalendarState(props = {}) {
 	};
 	const visibleRangeEnd = (start) => {
 		let end = endOfMonth$1(start);
-		for (let i = 1; i < visibleMonths; i++) end = endOfMonth$1(end.add({ months: 1 }));
+		for (let i = 1; i < visibleMonths(); i++) end = endOfMonth$1(end.add({ months: 1 }));
 		return end;
 	};
 	const constrainDate = (date) => {
@@ -1798,11 +2823,11 @@ function createCalendarState(props = {}) {
 		return toCalendar$1(today$1(timeZone), calendar());
 	};
 	const initialFocusedDate = constrainDate(getInitialFocusedDate());
-	const [internalValue, setInternalValue] = createSignal(props.defaultValue ?? null);
-	const [focusedDate, setFocusedDateInternal] = createSignal(initialFocusedDate);
-	const [visibleRangeStart, setVisibleRangeStart] = createSignal(alignVisibleRangeStart(initialFocusedDate));
-	const [isFocused, setFocused] = createSignal(props.autoFocus ?? false);
-	const [isPaginating, setIsPaginating] = createSignal(false);
+	const [internalValue, setInternalValue] = createInternalSignal(props.defaultValue ?? null);
+	const [focusedDate, setFocusedDateInternal] = createInternalSignal(initialFocusedDate);
+	const [visibleRangeStart, setVisibleRangeStart] = createInternalSignal(alignVisibleRangeStart(initialFocusedDate));
+	const [isFocused, setFocused] = createInternalSignal(props.autoFocus ?? false);
+	const [isPaginating, setIsPaginating] = createInternalSignal(false);
 	const sourceValue = createMemo(() => {
 		const controlled = access(props.value);
 		return controlled !== void 0 ? controlled : internalValue();
@@ -1816,41 +2841,61 @@ function createCalendarState(props = {}) {
 	const isReadOnly = createMemo(() => access(props.isReadOnly) ?? false);
 	const validationState = createMemo(() => access(props.validationState));
 	const isValueInvalid = createMemo(() => validationState() === "invalid");
-	const visibleRange = createMemo(() => {
+	const visibleRange = () => {
 		const start = visibleRangeStart();
 		return {
 			start,
 			end: visibleRangeEnd(start)
 		};
-	});
-	const syncVisibleRangeForFocusedDate = (nextFocusedDate) => {
-		const range = visibleRange();
-		if (nextFocusedDate.compare(range.start) < 0) setVisibleRangeStart(startOfMonth$1(nextFocusedDate.subtract({ months: visibleMonths - 1 })));
+	};
+	const syncVisibleRangeForFocusedDate = (nextFocusedDate, range, months) => {
+		if (nextFocusedDate.compare(range.start) < 0) setVisibleRangeStart(startOfMonth$1(nextFocusedDate.subtract({ months: months - 1 })));
 		else if (nextFocusedDate.compare(range.end) > 0) setVisibleRangeStart(startOfMonth$1(nextFocusedDate));
 	};
 	createEffect(() => {
 		const controlledFocused = access(props.focusedValue);
-		if (!controlledFocused) return;
-		const nextFocusedDate = constrainDate(toDisplayCalendarDate(controlledFocused));
-		const currentFocusedDate = focusedDate();
+		if (!controlledFocused) return null;
+		return {
+			nextFocusedDate: constrainDate(toDisplayCalendarDate(controlledFocused)),
+			currentFocusedDate: focusedDate(),
+			range: visibleRange(),
+			months: visibleMonths()
+		};
+	}, (data) => {
+		if (!data) return;
+		const { nextFocusedDate, currentFocusedDate, range, months } = data;
 		if (nextFocusedDate.compare(currentFocusedDate) !== 0 || !isEqualCalendar(nextFocusedDate.calendar, currentFocusedDate.calendar)) setFocusedDateInternal(nextFocusedDate);
-		syncVisibleRangeForFocusedDate(nextFocusedDate);
+		syncVisibleRangeForFocusedDate(nextFocusedDate, range, months);
 	});
 	createEffect(() => {
-		if (access(props.focusedValue)) return;
+		if (access(props.focusedValue)) return null;
 		const currentFocusedDate = focusedDate();
 		const nextFocusedDate = constrainDate(currentFocusedDate);
-		if (nextFocusedDate.compare(currentFocusedDate) === 0 && isEqualCalendar(nextFocusedDate.calendar, currentFocusedDate.calendar)) return;
-		syncVisibleRangeForFocusedDate(nextFocusedDate);
-		setFocusedDateInternal(nextFocusedDate);
-		props.onFocusChange?.(nextFocusedDate);
+		if (nextFocusedDate.compare(currentFocusedDate) === 0 && isEqualCalendar(nextFocusedDate.calendar, currentFocusedDate.calendar)) return null;
+		return {
+			currentFocusedDate,
+			nextFocusedDate,
+			range: visibleRange(),
+			months: visibleMonths()
+		};
+	}, (data) => {
+		if (!data) return;
+		syncVisibleRangeForFocusedDate(data.nextFocusedDate, data.range, data.months);
+		setFocusedDateInternal(data.nextFocusedDate);
+		props.onFocusChange?.(data.nextFocusedDate);
 	});
 	createEffect(() => {
 		const currentFocusedDate = focusedDate();
 		const nextFocusedDate = toDisplayCalendarDate(currentFocusedDate);
-		if (isEqualCalendar(currentFocusedDate.calendar, nextFocusedDate.calendar)) return;
-		setFocusedDateInternal(nextFocusedDate);
-		setVisibleRangeStart(alignVisibleRangeStart(nextFocusedDate));
+		if (isEqualCalendar(currentFocusedDate.calendar, nextFocusedDate.calendar)) return null;
+		return {
+			nextFocusedDate,
+			alignedStart: alignVisibleRangeStart(nextFocusedDate)
+		};
+	}, (data) => {
+		if (!data) return;
+		setFocusedDateInternal(data.nextFocusedDate);
+		setVisibleRangeStart(data.alignedStart);
 	});
 	const weekDays = createMemo(() => {
 		const formatter = new DateFormatter$1(locale(), { weekday: "narrow" });
@@ -1872,21 +2917,32 @@ function createCalendarState(props = {}) {
 		const formattableMonth = date.calendar.getFormattableMonth?.(date) ?? date;
 		return formatter.format(formattableMonth.toDate(timeZone));
 	});
+	const normalizeValue = (newValue) => {
+		const constrained = constrainDate(newValue);
+		const minBound = access(props.minValue);
+		const prev = previousAvailableDate$1(constrained, minBound != null ? toDisplayCalendarDate(minBound) : minDate$1(constrained, visibleRange().start) ?? constrained, props.isDateUnavailable);
+		if (!prev) return null;
+		const oldValue = sourceValue();
+		return convertValue$3(prev, Array.isArray(oldValue) ? oldValue[0] ?? null : oldValue);
+	};
 	const setValue = (newValue) => {
 		if (isDisabled() || isReadOnly()) return;
 		const oldValue = sourceValue();
-		const referenceValue = Array.isArray(oldValue) ? oldValue[0] ?? null : oldValue;
 		let nextValue;
 		if (newValue == null) nextValue = selectionMode() === "multiple" ? [] : null;
-		else if (Array.isArray(newValue)) nextValue = newValue.map((v) => convertValue$3(constrainDate(toDisplayCalendarDate(v)), referenceValue));
-		else nextValue = convertValue$3(constrainDate(toDisplayCalendarDate(newValue)), referenceValue);
+		else if (Array.isArray(newValue)) nextValue = newValue.map((v) => normalizeValue(toDisplayCalendarDate(v))).filter((v) => v != null);
+		else {
+			const localValue = normalizeValue(toDisplayCalendarDate(newValue));
+			if (!localValue) return;
+			nextValue = localValue;
+		}
 		if (access(props.value) === void 0) setInternalValue(() => nextValue);
 		if (!Object.is(oldValue, nextValue) && props.onChange) props.onChange(nextValue);
 	};
 	const setFocusedDate = (date) => {
 		const constrained = constrainDate(date);
 		if (Object.is(constrained, focusedDate())) return;
-		syncVisibleRangeForFocusedDate(constrained);
+		syncVisibleRangeForFocusedDate(constrained, visibleRange(), visibleMonths());
 		setFocusedDateInternal(constrained);
 		props.onFocusChange?.(constrained);
 	};
@@ -1924,9 +2980,27 @@ function createCalendarState(props = {}) {
 	const isInvalid = (date) => {
 		return isCellDisabled(date) || isCellUnavailable(date);
 	};
+	const isDateOutsideAllowedRange = (date) => {
+		const min = minValueState();
+		const max = maxValueState();
+		const calDate = toDisplayCalendarDate(date);
+		if (min && calDate.compare(toDisplayCalendarDate(min)) < 0) return true;
+		if (max && calDate.compare(toDisplayCalendarDate(max)) > 0) return true;
+		return false;
+	};
+	const isPreviousVisibleRangeInvalid = () => {
+		const start = visibleRange().start;
+		const previous = start.subtract({ days: 1 });
+		return isSameDay$1(previous, start) || isDateOutsideAllowedRange(previous);
+	};
+	const isNextVisibleRangeInvalid = () => {
+		const end = visibleRange().end;
+		const next = end.add({ days: 1 });
+		return isSameDay$1(next, end) || isDateOutsideAllowedRange(next);
+	};
 	const focusPreviousPage = () => {
 		setIsPaginating(true);
-		const pageMonths = props.pageBehavior === "single" ? 1 : visibleMonths;
+		const pageMonths = props.pageBehavior === "single" ? 1 : visibleMonths();
 		const nextFocusedDate = constrainDate(focusedDate().subtract({ months: pageMonths }));
 		setFocusedDateInternal(nextFocusedDate);
 		setVisibleRangeStart(startOfMonth$1(visibleRangeStart().subtract({ months: pageMonths })));
@@ -1935,7 +3009,7 @@ function createCalendarState(props = {}) {
 	};
 	const focusNextPage = () => {
 		setIsPaginating(true);
-		const pageMonths = props.pageBehavior === "single" ? 1 : visibleMonths;
+		const pageMonths = props.pageBehavior === "single" ? 1 : visibleMonths();
 		const nextFocusedDate = constrainDate(focusedDate().add({ months: pageMonths }));
 		setFocusedDateInternal(nextFocusedDate);
 		setVisibleRangeStart(startOfMonth$1(visibleRangeStart().add({ months: pageMonths })));
@@ -1974,17 +3048,19 @@ function createCalendarState(props = {}) {
 	const selectDate = (date) => {
 		if (isReadOnly() || isDisabled()) return;
 		if (selectionMode() === "multiple") {
-			const current = value();
+			const current = access(props.value) !== void 0 ? value() : readNow(internalValue);
 			const base = Array.isArray(current) ? current.map((v) => toDisplayCalendarDate(v)) : current != null ? [toDisplayCalendarDate(current)] : [];
 			const target = toDisplayCalendarDate(date);
 			const index = base.findIndex((d) => isSameDay$1(d, target));
-			setValue(index >= 0 ? [...base.slice(0, index), ...base.slice(index + 1)] : [...base, target]);
+			const nextValue = index >= 0 ? [...base.slice(0, index), ...base.slice(index + 1)] : [...base, target];
+			setValue(nextValue);
 		} else setValue(date);
 		setFocusedDate(date);
 	};
 	const getDatesInWeek = (weekIndex, monthStartDate) => {
 		const startDate = monthStartDate ?? visibleRange().start;
-		const weekStart = startOfWeek$1(startOfMonth$1(startDate), locale(), firstDayOfWeekName());
+		const monthStart = startOfMonth$1(startDate);
+		const weekStart = startOfWeek$1(monthStart, locale(), firstDayOfWeekName());
 		const week = [];
 		const firstDayOfWeek = weekStart.add({ weeks: weekIndex });
 		for (let i = 0; i < 7; i++) {
@@ -1995,7 +3071,8 @@ function createCalendarState(props = {}) {
 		return week;
 	};
 	const getWeeksInMonthFn = (date) => {
-		return getWeeksInMonth$1(date ?? focusedDate(), locale(), firstDayOfWeekName());
+		const monthDate = date ?? focusedDate();
+		return getWeeksInMonth$1(monthDate, locale(), firstDayOfWeekName());
 	};
 	return {
 		selectionMode,
@@ -2019,6 +3096,8 @@ function createCalendarState(props = {}) {
 		isCellDisabled,
 		isOutsideVisibleRange,
 		isInvalid,
+		isPreviousVisibleRangeInvalid,
+		isNextVisibleRangeInvalid,
 		focusPreviousPage,
 		focusNextPage,
 		focusPreviousSection,
@@ -2037,7 +3116,9 @@ function createCalendarState(props = {}) {
 		getWeeksInMonth: getWeeksInMonthFn,
 		weekDays,
 		title,
-		visibleMonths,
+		get visibleMonths() {
+			return visibleMonths();
+		},
 		isPaginating
 	};
 }
@@ -2052,6 +3133,16 @@ function convertValue$3(newValue, oldValue) {
 	if (oldValue && "hour" in oldValue) return oldValue.set(localValue);
 	return localValue;
 }
+/**
+* Walks backward from `date` while it is unavailable and still at/after `minValue`.
+* Mirrors @react-stately/calendar previousAvailableDate.
+*/
+function previousAvailableDate$1(date, minValue, isDateUnavailable) {
+	if (!isDateUnavailable) return date;
+	while (date.compare(minValue) >= 0 && isDateUnavailable(date)) date = date.subtract({ days: 1 });
+	if (date.compare(minValue) >= 0) return date;
+	return null;
+}
 //#endregion
 //#region src/calendar/IncompleteDate.ts
 /**
@@ -2062,7 +3153,7 @@ function convertValue$3(newValue, oldValue) {
 * This lets a date field hold an invalid intermediate value while typing and
 * only constrain it on blur, matching upstream behavior.
 *
-* Based on @react-stately/datepicker IncompleteDate
+* Ported from packages/react-stately/src/datepicker/IncompleteDate.ts.
 */
 /**
 * This class represents a date that is incomplete or otherwise invalid as a result of user editing.
@@ -2217,9 +3308,7 @@ var IncompleteDate = class IncompleteDate {
 			case "minute":
 				res.minute = cycleValue(res.minute ?? 0, amount, 0, 59, true);
 				break;
-			case "second":
-				res.second = cycleValue(res.second ?? 0, amount, 0, 59, true);
-				break;
+			case "second": res.second = cycleValue(res.second ?? 0, amount, 0, 59, true);
 		}
 		return res;
 	}
@@ -2353,9 +3442,7 @@ function fromHourCycle(hour, dayPeriod, hourCycle) {
 			if (hour === 12) hour = 0;
 			if (dayPeriod === 1) hour += 12;
 			break;
-		case "h24":
-			hour -= 1;
-			break;
+		case "h24": hour -= 1;
 	}
 	return hour;
 }
@@ -3006,8 +4093,8 @@ function getPlaceholder(field, value, locale) {
 *
 * The upstream "derived state during render" resync (which re-mints the display
 * value when the committed value / calendar / hour cycle changes) is ported to a
-* Solid `createComputed` so it runs synchronously before render effects — mirroring
-* React's render-phase setState rather than a post-render `createEffect`.
+* split `createEffect`. Compute tracks the committed value; apply writes the
+* display override. Solid 2 has no `createComputed`.
 */
 const EDITABLE_SEGMENTS = {
 	year: true,
@@ -3037,26 +4124,26 @@ const TYPE_MAPPING = {
 * Provides state management for a date field component.
 */
 function createDateFieldState(props = {}) {
-	const locale = () => props.locale ?? "en-US";
+	const locale = createMemo(() => access(props.locale) ?? "en-US");
 	const createCalendarFn = (name) => (props.createCalendar ?? createCalendar$1)(name);
 	const v0 = () => access(props.value) ?? props.defaultValue ?? props.placeholderValue ?? null;
-	const [lastDefaults, setLastDefaults] = createSignal(untrack(() => {
+	const initialDefaults = untrack(() => {
 		const v = v0();
 		return {
 			granularity: v && "minute" in v ? "minute" : "day",
 			timeZone: v && "timeZone" in v ? v.timeZone : void 0
 		};
-	}));
-	createComputed(() => {
+	});
+	const lastDefaults = createMemo((prev = initialDefaults) => {
 		const v = v0();
-		if (!v) return;
+		if (!v) return prev;
 		const defaultGranularity = "minute" in v ? "minute" : "day";
 		const defaultTimeZone = "timeZone" in v ? v.timeZone : void 0;
-		const last = untrack(lastDefaults);
-		if (last.granularity !== defaultGranularity || last.timeZone !== defaultTimeZone) setLastDefaults({
+		if (prev.granularity !== defaultGranularity || prev.timeZone !== defaultTimeZone) return {
 			granularity: defaultGranularity,
 			timeZone: defaultTimeZone
-		});
+		};
+		return prev;
 	});
 	const granularity = () => {
 		if (props.granularity) return props.granularity;
@@ -3079,7 +4166,7 @@ function createDateFieldState(props = {}) {
 	});
 	const calendar = () => calendarAndHourCycle()[0];
 	const hourCycle = () => calendarAndHourCycle()[1];
-	const [internalValue, setInternalValue] = createSignal(props.defaultValue ?? null);
+	const [internalValue, setInternalValue] = createInternalSignal(props.defaultValue ?? null);
 	const rawValue = createMemo(() => {
 		const controlled = access(props.value);
 		return controlled !== void 0 ? controlled : internalValue();
@@ -3090,14 +4177,15 @@ function createDateFieldState(props = {}) {
 	};
 	const calendarValue = createMemo(() => convertValue$2(rawValue(), calendar()) ?? null);
 	const initialValue = untrack(calendarValue);
-	const [displayValue, setDisplayValue] = createSignal(untrack(() => new IncompleteDate(calendar(), hourCycle(), untrack(calendarValue))));
+	const [displayValue, setDisplayValue] = createInternalSignal(untrack(() => new IncompleteDate(calendar(), hourCycle(), untrack(calendarValue))));
 	let lastValue = untrack(calendarValue);
 	let lastCalendar = untrack(calendar);
 	let lastHourCycle = untrack(hourCycle);
-	createComputed(() => {
-		const cv = calendarValue();
-		const cal = calendar();
-		const hc = hourCycle();
+	createEffect(() => ({
+		cv: calendarValue(),
+		cal: calendar(),
+		hc: hourCycle()
+	}), ({ cv, cal, hc }) => {
 		if (cv !== lastValue || hc !== lastHourCycle || !isEqualCalendar(cal, lastCalendar)) {
 			lastValue = cv;
 			lastCalendar = cal;
@@ -3251,7 +4339,9 @@ function createDateFieldState(props = {}) {
 			if (access(props.isDisabled) || access(props.isReadOnly)) return;
 			if (displayValue().isComplete(displaySegments())) {
 				const cv = calendarValue();
-				const newDateValue = toCalendar$1(displayValue().toValue(cv ?? placeholderDate()), v0()?.calendar || new GregorianCalendar$1());
+				const dv = displayValue().toValue(cv ?? placeholderDate());
+				const v = v0();
+				const newDateValue = toCalendar$1(dv, v?.calendar || new GregorianCalendar$1());
 				const committed = rawValue();
 				if (!committed || newDateValue.compare(committed) !== 0) setDate(newDateValue);
 				setDisplayValue(new IncompleteDate(calendar(), hourCycle(), cv));
@@ -3268,10 +4358,11 @@ function createDateFieldState(props = {}) {
 			return new DateFormatter$1(locale(), formatOptions).format(dateValue());
 		},
 		getDateFormatter(loc, formatOptions) {
-			return new DateFormatter$1(loc, getFormatOptions({}, {
+			const newFormatOptions = getFormatOptions({}, {
 				...formatOpts(),
 				...formatOptions
-			}));
+			});
+			return new DateFormatter$1(loc, newFormatOptions);
 		},
 		get locale() {
 			return locale();
@@ -3447,7 +4538,10 @@ function formatError(locale, key, args) {
 * RangeCalendarState for Solid-Stately
 *
 * Provides state management for range calendar components.
-* Based on @react-stately/calendar useRangeCalendarState
+* Ported from:
+* - packages/react-stately/src/calendar/useRangeCalendarState.ts
+* - packages/react-stately/src/calendar/useCalendarState.ts
+* - packages/react-stately/src/calendar/utils.ts
 */
 const dayOfWeekNames = [
 	"sun",
@@ -3468,16 +4562,16 @@ function createRangeCalendarState(props = {}) {
 	const maxValueState = createMemo(() => access(props.maxValue) ?? null);
 	const resolvedOptions = createMemo(() => new DateFormatter$1(locale()).resolvedOptions());
 	const calendar = createMemo(() => (props.createCalendar ?? createCalendar$1)(resolvedOptions().calendar));
-	const visibleMonths = Math.max(1, Number(access(props.visibleMonths) ?? 1));
+	const visibleMonths = createMemo(() => Math.max(1, Number(access(props.visibleMonths) ?? 1)));
 	const firstDayOfWeekName = () => props.firstDayOfWeek == null ? void 0 : dayOfWeekNames[props.firstDayOfWeek];
 	const toDisplayCalendarDate = (date) => toCalendar$1(toCalendarDate$2(date), calendar());
-	const [anchorDate, setAnchorDate] = createSignal(null);
+	const [anchorDate, setAnchorDate] = createInternalSignal(null);
 	const getAvailableRange = (anchor) => {
 		if (anchor && props.isDateUnavailable && !props.allowsNonContiguousRanges) {
 			const predicate = (date) => props.isDateUnavailable(date, anchor);
 			return {
-				start: nextUnavailableDate(anchor, predicate, visibleMonths, -1),
-				end: nextUnavailableDate(anchor, predicate, visibleMonths, 1)
+				start: nextUnavailableDate(anchor, predicate, visibleMonths(), -1),
+				end: nextUnavailableDate(anchor, predicate, visibleMonths(), 1)
 			};
 		}
 		return null;
@@ -3485,11 +4579,13 @@ function createRangeCalendarState(props = {}) {
 	const availableRange = createMemo(() => getAvailableRange(anchorDate()));
 	const effectiveMinValue = createMemo(() => {
 		const min = access(props.minValue);
-		return maxDate$1(min != null ? toDisplayCalendarDate(min) : void 0, availableRange()?.start) ?? null;
+		const minCal = min != null ? toDisplayCalendarDate(min) : void 0;
+		return maxDate$1(minCal, availableRange()?.start) ?? null;
 	});
 	const effectiveMaxValue = createMemo(() => {
 		const max = access(props.maxValue);
-		return minDate$1(max != null ? toDisplayCalendarDate(max) : void 0, availableRange()?.end) ?? null;
+		const maxCal = max != null ? toDisplayCalendarDate(max) : void 0;
+		return minDate$1(maxCal, availableRange()?.end) ?? null;
 	});
 	const constrainDate = (date) => {
 		const min = effectiveMinValue();
@@ -3501,11 +4597,11 @@ function createRangeCalendarState(props = {}) {
 	};
 	const visibleRangeEndFromStart = (start) => {
 		let end = endOfMonth$1(start);
-		for (let i = 1; i < visibleMonths; i++) end = endOfMonth$1(end.add({ months: 1 }));
+		for (let i = 1; i < visibleMonths(); i++) end = endOfMonth$1(end.add({ months: 1 }));
 		return end;
 	};
 	const rawAlignStart = (date) => startOfMonth$1(date);
-	const rawAlignEnd = (date) => startOfMonth$1(date).subtract({ months: Math.max(visibleMonths - 1, 0) });
+	const rawAlignEnd = (date) => startOfMonth$1(date).subtract({ months: Math.max(visibleMonths() - 1, 0) });
 	const constrainVisibleRangeStart = (date, aligned) => {
 		const minValue = access(props.minValue);
 		const maxValue = access(props.maxValue);
@@ -3523,14 +4619,15 @@ function createRangeCalendarState(props = {}) {
 	const alignStart = (date) => constrainVisibleRangeStart(date, rawAlignStart(date));
 	const alignEnd = (date) => constrainVisibleRangeStart(date, rawAlignEnd(date));
 	const alignCenter = (date) => {
-		let offset = Math.floor(visibleMonths / 2);
-		if (offset > 0 && visibleMonths % 2 === 0) offset--;
+		let offset = Math.floor(visibleMonths() / 2);
+		if (offset > 0 && visibleMonths() % 2 === 0) offset--;
 		return constrainVisibleRangeStart(date, rawAlignStart(date).subtract({ months: offset }));
 	};
 	const defaultSelectionAlignment = () => {
 		const currentValue = access(props.value) ?? props.defaultValue;
 		if (!currentValue?.start || !currentValue?.end) return "center";
-		const end = visibleRangeEndFromStart(alignCenter(toDisplayCalendarDate(currentValue.start)));
+		const start = alignCenter(toDisplayCalendarDate(currentValue.start));
+		const end = visibleRangeEndFromStart(start);
 		return toDisplayCalendarDate(currentValue.end).compare(end) > 0 ? "start" : "center";
 	};
 	const alignVisibleRangeStart = (date) => {
@@ -3549,12 +4646,12 @@ function createRangeCalendarState(props = {}) {
 		if (props.defaultValue?.start) return toDisplayCalendarDate(props.defaultValue.start);
 		return toCalendar$1(today$1(timeZone), calendar());
 	};
-	const [internalValue, setInternalValue] = createSignal(props.defaultValue ?? null);
+	const [internalValue, setInternalValue] = createInternalSignal(props.defaultValue ?? null);
 	const initialFocusedDate = constrainDate(getInitialFocusedDate());
-	const [focusedDate, setFocusedDateInternal] = createSignal(initialFocusedDate);
-	const [visibleRangeStart, setVisibleRangeStart] = createSignal(alignVisibleRangeStart(initialFocusedDate));
-	const [isFocused, setFocused] = createSignal(false);
-	const [isDragging, setDragging] = createSignal(false);
+	const [focusedDate, setFocusedDateInternal] = createInternalSignal(initialFocusedDate);
+	const [visibleRangeStart, setVisibleRangeStart] = createInternalSignal(alignVisibleRangeStart(initialFocusedDate));
+	const [isFocused, setFocused] = createInternalSignal(false);
+	const [isDragging, setDragging] = createInternalSignal(false);
 	const sourceValue = createMemo(() => {
 		const controlled = access(props.value);
 		return controlled !== void 0 ? controlled : internalValue();
@@ -3608,36 +4705,54 @@ function createRangeCalendarState(props = {}) {
 			end: visibleRangeEndFromStart(start)
 		};
 	});
-	const syncVisibleRangeForFocusedDate = (nextFocusedDate) => {
-		const range = visibleRange();
+	const syncVisibleRangeForFocusedDate = (nextFocusedDate, range) => {
 		if (nextFocusedDate.compare(range.start) < 0) setVisibleRangeStart(alignEnd(nextFocusedDate));
 		else if (nextFocusedDate.compare(range.end) > 0) setVisibleRangeStart(alignStart(nextFocusedDate));
 	};
 	createEffect(() => {
 		const controlledFocused = access(props.focusedValue);
-		if (!controlledFocused) return;
+		if (!controlledFocused) return null;
 		const nextFocusedDate = constrainDate(toDisplayCalendarDate(controlledFocused));
-		const currentFocusedDate = focusedDate();
+		return {
+			nextFocusedDate,
+			currentFocusedDate: focusedDate(),
+			alignedStart: alignVisibleRangeStart(nextFocusedDate)
+		};
+	}, (data) => {
+		if (!data) return;
+		const { nextFocusedDate, currentFocusedDate, alignedStart } = data;
 		if (nextFocusedDate.compare(currentFocusedDate) !== 0 || !isEqualCalendar(nextFocusedDate.calendar, currentFocusedDate.calendar)) {
 			setFocusedDateInternal(nextFocusedDate);
-			setVisibleRangeStart(alignVisibleRangeStart(nextFocusedDate));
+			setVisibleRangeStart(alignedStart);
 		}
 	});
 	createEffect(() => {
-		if (access(props.focusedValue)) return;
+		if (access(props.focusedValue)) return null;
 		const currentFocusedDate = focusedDate();
 		const nextFocusedDate = constrainDate(currentFocusedDate);
-		if (nextFocusedDate.compare(currentFocusedDate) === 0 && isEqualCalendar(nextFocusedDate.calendar, currentFocusedDate.calendar)) return;
-		setFocusedDateInternal(nextFocusedDate);
-		setVisibleRangeStart(alignVisibleRangeStart(nextFocusedDate));
-		props.onFocusChange?.(nextFocusedDate);
+		if (nextFocusedDate.compare(currentFocusedDate) === 0 && isEqualCalendar(nextFocusedDate.calendar, currentFocusedDate.calendar)) return null;
+		return {
+			nextFocusedDate,
+			alignedStart: alignVisibleRangeStart(nextFocusedDate)
+		};
+	}, (data) => {
+		if (!data) return;
+		setFocusedDateInternal(data.nextFocusedDate);
+		setVisibleRangeStart(data.alignedStart);
+		props.onFocusChange?.(data.nextFocusedDate);
 	});
 	createEffect(() => {
 		const currentFocusedDate = focusedDate();
 		const nextFocusedDate = toDisplayCalendarDate(currentFocusedDate);
-		if (isEqualCalendar(currentFocusedDate.calendar, nextFocusedDate.calendar)) return;
-		setFocusedDateInternal(nextFocusedDate);
-		setVisibleRangeStart(alignVisibleRangeStart(nextFocusedDate));
+		if (isEqualCalendar(currentFocusedDate.calendar, nextFocusedDate.calendar)) return null;
+		return {
+			nextFocusedDate,
+			alignedStart: alignVisibleRangeStart(nextFocusedDate)
+		};
+	}, (data) => {
+		if (!data) return;
+		setFocusedDateInternal(data.nextFocusedDate);
+		setVisibleRangeStart(data.alignedStart);
 	});
 	const weekDays = createMemo(() => {
 		const formatter = new DateFormatter$1(locale(), { weekday: "narrow" });
@@ -3672,7 +4787,7 @@ function createRangeCalendarState(props = {}) {
 	const setFocusedDate = (date) => {
 		const constrained = constrainDate(date);
 		if (Object.is(constrained, focusedDate())) return;
-		syncVisibleRangeForFocusedDate(constrained);
+		syncVisibleRangeForFocusedDate(constrained, visibleRange());
 		setFocusedDateInternal(constrained);
 		props.onFocusChange?.(constrained);
 	};
@@ -3728,14 +4843,14 @@ function createRangeCalendarState(props = {}) {
 		return isCellDisabled(date) || isCellUnavailable(date);
 	};
 	const focusPreviousPage = () => {
-		const pageMonths = access(props.pageBehavior) === "single" ? 1 : visibleMonths;
+		const pageMonths = access(props.pageBehavior) === "single" ? 1 : visibleMonths();
 		const nextFocusedDate = constrainDate(focusedDate().subtract({ months: pageMonths }));
 		setFocusedDateInternal(nextFocusedDate);
 		setVisibleRangeStart(startOfMonth$1(visibleRangeStart().subtract({ months: pageMonths })));
 		props.onFocusChange?.(nextFocusedDate);
 	};
 	const focusNextPage = () => {
-		const pageMonths = access(props.pageBehavior) === "single" ? 1 : visibleMonths;
+		const pageMonths = access(props.pageBehavior) === "single" ? 1 : visibleMonths();
 		const nextFocusedDate = constrainDate(focusedDate().add({ months: pageMonths }));
 		setFocusedDateInternal(nextFocusedDate);
 		setVisibleRangeStart(startOfMonth$1(visibleRangeStart().add({ months: pageMonths })));
@@ -3785,7 +4900,7 @@ function createRangeCalendarState(props = {}) {
 		const predicate = props.isDateUnavailable ? (d) => props.isDateUnavailable(d, anchorDate()) : void 0;
 		const selectableDate = previousAvailableDate(constrainedDate, toDisplayCalendarDate(visibleRange().start), predicate);
 		if (!selectableDate) return;
-		const anchor = anchorDate();
+		const anchor = readNow(anchorDate);
 		if (!anchor) {
 			setAnchorDate(selectableDate);
 			setDragging(true);
@@ -3809,7 +4924,9 @@ function createRangeCalendarState(props = {}) {
 		setFocusedDate(selectableDate);
 	};
 	const getDatesInWeek = (weekIndex, monthStartDate) => {
-		const weekStart = startOfWeek$1(startOfMonth$1(monthStartDate ?? visibleRange().start), locale(), firstDayOfWeekName());
+		const startDate = monthStartDate ?? visibleRange().start;
+		const monthStart = startOfMonth$1(startDate);
+		const weekStart = startOfWeek$1(monthStart, locale(), firstDayOfWeekName());
 		const week = [];
 		const firstDayOfWeek = weekStart.add({ weeks: weekIndex });
 		for (let i = 0; i < 7; i++) {
@@ -3818,8 +4935,18 @@ function createRangeCalendarState(props = {}) {
 		}
 		return week;
 	};
+	const focusNearestAvailableDate = (anchor) => {
+		const isDateInvalid = (candidate) => isInvalid(candidate) || isDateOutsideAllowedRange(candidate);
+		let nextDay = anchor.add({ days: 1 });
+		if (isDateInvalid(nextDay)) nextDay = anchor.subtract({ days: 1 });
+		if (!isDateInvalid(nextDay)) {
+			setFocusedDate(nextDay);
+			setFocused(true);
+		}
+	};
 	const getWeeksInMonthFn = (date) => {
-		return getWeeksInMonth$1(date ?? focusedDate(), locale(), firstDayOfWeekName());
+		const monthDate = date ?? focusedDate();
+		return getWeeksInMonth$1(monthDate, locale(), firstDayOfWeekName());
 	};
 	const formatValue = (locale2, fieldOptions) => {
 		const v = value();
@@ -3858,10 +4985,13 @@ function createRangeCalendarState(props = {}) {
 				};
 			} catch {}
 			endFormatter = startFormatter;
-		} else endFormatter = new DateFormatter$1(locale2, getFormatOptions(fieldOptions, {
-			granularity: endGranularity,
-			timeZone: endTimeZone
-		}));
+		} else {
+			const endOptions = getFormatOptions(fieldOptions, {
+				granularity: endGranularity,
+				timeZone: endTimeZone
+			});
+			endFormatter = new DateFormatter$1(locale2, endOptions);
+		}
 		return {
 			start: startFormatter.format(startDate),
 			end: endFormatter.format(endDate)
@@ -3907,13 +5037,16 @@ function createRangeCalendarState(props = {}) {
 		focusPageEnd,
 		selectFocusedDate,
 		selectDate,
+		focusNearestAvailableDate,
 		isFocused,
 		setFocused,
 		getDatesInWeek,
 		getWeeksInMonth: getWeeksInMonthFn,
 		weekDays,
 		title,
-		visibleMonths,
+		get visibleMonths() {
+			return visibleMonths();
+		},
 		isDragging,
 		setDragging,
 		formatValue
@@ -3966,8 +5099,9 @@ function nextUnavailableDate(anchorDate, isDateUnavailable, visibleMonths, dir)
 /**
 * TimeFieldState for Solid-Stately
 *
-* Faithful port of `@react-stately/datepicker` `useTimeFieldState`, which is a
-* thin wrapper over `useDateFieldState`: a time-only `Time` value is converted
+* Faithful port of
+* `packages/react-stately/src/datepicker/useTimeFieldState.ts`, which is a thin
+* wrapper over `useDateFieldState`: a time-only `Time` value is converted
 * to a `CalendarDateTime` (anchored on today's date, or a zoned date when the
 * value/default carries a time zone) and fed to the date-field state machine
 * with `maxGranularity: 'hour'` so the date segments drop away and only
@@ -3998,7 +5132,7 @@ function convertValue(value, date = today$1(getLocalTimeZone$1())) {
 */
 function createTimeFieldState(props = {}) {
 	const placeholderValue = props.placeholderValue ?? new Time();
-	const [internalValue, setInternalValue] = createSignal(props.defaultValue ?? null);
+	const [internalValue, setInternalValue] = createInternalSignal(props.defaultValue ?? null);
 	const value = () => {
 		const controlled = access(props.value);
 		return controlled !== void 0 ? controlled : internalValue();
@@ -4115,14 +5249,14 @@ function createTimeFieldState(props = {}) {
 */
 function createDatePickerState(props = {}) {
 	const timeZone = getLocalTimeZone$1();
-	const [internalValue, setInternalValue] = createSignal(props.defaultValue ?? null);
-	const [internalOpen, setInternalOpen] = createSignal(props.defaultOpen ?? false);
-	const [selectedDate, setSelectedDate] = createSignal(null);
-	const [selectedTime, setSelectedTime] = createSignal(null);
-	const value = createMemo(() => {
+	const [internalValue, setInternalValue] = createInternalSignal(props.defaultValue ?? null);
+	const [internalOpen, setInternalOpen] = createInternalSignal(props.defaultOpen ?? false);
+	const [selectedDate, setSelectedDate] = createInternalSignal(null);
+	const [selectedTime, setSelectedTime] = createInternalSignal(null);
+	const value = () => {
 		const controlled = access(props.value);
 		return controlled !== void 0 ? controlled : internalValue();
-	});
+	};
 	const granularity = createMemo(() => {
 		if (props.granularity) return props.granularity;
 		const v = value();
@@ -4139,7 +5273,7 @@ function createDatePickerState(props = {}) {
 	const isDisabled = createMemo(() => access(props.isDisabled) ?? false);
 	const isReadOnly = createMemo(() => access(props.isReadOnly) ?? false);
 	const validationState = createMemo(() => access(props.validationState));
-	const isOpen = () => access(props.isOpen) ?? internalOpen();
+	const isOpen = () => access(props.isOpen) ?? readNow(internalOpen);
 	const dateValue = createMemo(() => {
 		const v = value();
 		if (!v) return null;
@@ -4176,11 +5310,12 @@ function createDatePickerState(props = {}) {
 	};
 	const setDateValue = (date) => {
 		if (isDisabled() || isReadOnly()) return;
-		const currentTime = selectedTime();
+		const currentTime = readNow(selectedTime);
 		const currentValue = value();
 		const shouldClose = typeof props.shouldCloseOnSelect === "function" ? props.shouldCloseOnSelect() : props.shouldCloseOnSelect ?? true;
 		if (hasTime() && (currentTime || shouldClose)) {
-			commitValue(date, currentTime ?? (currentValue && "hour" in currentValue ? currentValue : null) ?? getPlaceholderTime());
+			const timePart = currentTime ?? (currentValue && "hour" in currentValue ? currentValue : null) ?? getPlaceholderTime();
+			commitValue(date, timePart);
 			if (shouldClose) setOpen(false);
 		} else if (hasTime()) setSelectedDate(date);
 		else {
@@ -4190,11 +5325,13 @@ function createDatePickerState(props = {}) {
 	};
 	const setTimeValue = (time) => {
 		if (isDisabled() || isReadOnly()) return;
-		const currentDate = selectedDate();
+		const currentDate = readNow(selectedDate);
 		const currentValue = value();
 		if (currentDate) commitValue(currentDate, time);
-		else if (currentValue && hasTime()) commitValue(toCalendarDate$1(currentValue), time);
-		else setSelectedTime(time);
+		else if (currentValue && hasTime()) {
+			const datePart = toCalendarDate$1(currentValue);
+			commitValue(datePart, time);
+		} else setSelectedTime(time);
 	};
 	const open = () => setOpen(true);
 	const close = () => setOpen(false);
@@ -4204,8 +5341,8 @@ function createDatePickerState(props = {}) {
 			props.onOpenChange?.(true);
 		} else {
 			const currentValue = value();
-			const currentDate = selectedDate();
-			const currentTime = selectedTime();
+			const currentDate = readNow(selectedDate);
+			const currentTime = readNow(selectedTime);
 			if (!currentValue && currentDate && hasTime() && currentTime) commitValue(currentDate, currentTime);
 			setSelectedDate(null);
 			setSelectedTime(null);
@@ -4292,8 +5429,8 @@ function createSelectState(props) {
 	});
 	const isControlledSingle = () => getProps().selectedKey !== void 0;
 	const isControlledMultiple = () => getProps().selectedKeys !== void 0;
-	const [internalSelectedKey, setInternalSelectedKey] = createSignal(getProps().defaultSelectedKey ?? null);
-	const [internalSelectedKeys, setInternalSelectedKeys] = createSignal(getProps().defaultSelectedKeys === "all" ? "all" : new Set(getProps().defaultSelectedKeys ?? []));
+	const [internalSelectedKey, setInternalSelectedKey] = createInternalSignal(getProps().defaultSelectedKey ?? null);
+	const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal(getProps().defaultSelectedKeys === "all" ? "all" : new Set(getProps().defaultSelectedKeys ?? []));
 	const selectedKey = () => {
 		if (selectionMode() === "multiple") {
 			const keys = selectedKeys();
@@ -4309,7 +5446,7 @@ function createSelectState(props) {
 				getProps().onSelectionChangeKeys?.(/* @__PURE__ */ new Set());
 				getProps().onSelectionChange?.(null);
 			} else {
-				const next = new Set([key]);
+				const next = /* @__PURE__ */ new Set([key]);
 				if (!isControlledMultiple()) setInternalSelectedKeys(next);
 				getProps().onSelectionChangeKeys?.(next);
 				getProps().onSelectionChange?.(key);
@@ -4318,7 +5455,7 @@ function createSelectState(props) {
 		}
 		if (!isControlledSingle()) setInternalSelectedKey(key);
 		getProps().onSelectionChange?.(key);
-		getProps().onSelectionChangeKeys?.(key != null ? new Set([key]) : /* @__PURE__ */ new Set());
+		getProps().onSelectionChangeKeys?.(key != null ? /* @__PURE__ */ new Set([key]) : /* @__PURE__ */ new Set());
 	};
 	const selectedKeys = createMemo(() => {
 		if (selectionMode() === "multiple") {
@@ -4329,7 +5466,7 @@ function createSelectState(props) {
 			return internalSelectedKeys();
 		}
 		const key = selectedKey();
-		return key != null ? new Set([key]) : /* @__PURE__ */ new Set();
+		return key != null ? /* @__PURE__ */ new Set([key]) : /* @__PURE__ */ new Set();
 	});
 	const setSelectedKeys = (keys) => {
 		const next = new Set(keys);
@@ -4339,8 +5476,29 @@ function createSelectState(props) {
 			getProps().onSelectionChange?.(next.size > 0 ? Array.from(next)[0] : null);
 			return;
 		}
-		setSelectedKey(next.size > 0 ? Array.from(next)[0] : null);
+		const key = next.size > 0 ? Array.from(next)[0] : null;
+		setSelectedKey(key);
 	};
+	const validation = createFormValidationState({
+		get value() {
+			return selectionMode() === "multiple" ? selectedKeys() : selectedKey();
+		},
+		get isInvalid() {
+			return getProps().isInvalid;
+		},
+		get validationState() {
+			return getProps().validationState;
+		},
+		get validate() {
+			return getProps().validate;
+		},
+		get name() {
+			return getProps().name;
+		},
+		get validationBehavior() {
+			return getProps().validationBehavior ?? "native";
+		}
+	});
 	const listState = createListState({
 		get items() {
 			return getProps().items;
@@ -4360,7 +5518,10 @@ function createSelectState(props) {
 		get selectionMode() {
 			return selectionMode();
 		},
-		disallowEmptySelection: true,
+		get disallowEmptySelection() {
+			return selectionMode() === "single";
+		},
+		allowDuplicateSelectionEvents: true,
 		get selectedKeys() {
 			const keys = selectedKeys();
 			if (keys === "all") return "all";
@@ -4371,14 +5532,17 @@ function createSelectState(props) {
 				if (!isControlledMultiple()) setInternalSelectedKeys(keys);
 				getProps().onSelectionChangeKeys?.(keys);
 				if (keys !== "all") getProps().onSelectionChange?.(keys.size > 0 ? Array.from(keys)[0] : null);
+				validation.commitValidation();
 				return;
 			}
 			if (keys === "all") return;
-			setSelectedKey(keys.size > 0 ? Array.from(keys)[0] : null);
+			const key = keys.size > 0 ? Array.from(keys)[0] : null;
+			setSelectedKey(key);
 			overlayState.close();
+			validation.commitValidation();
 		}
 	});
-	const [isFocused, setFocused] = createSignal(false);
+	const [isFocused, setFocused] = createInternalSignal(false);
 	const selectedItem = createMemo(() => {
 		const key = selectedKey();
 		if (key == null) return null;
@@ -4395,6 +5559,11 @@ function createSelectState(props) {
 		return items;
 	});
 	return {
+		realtimeValidation: validation.realtimeValidation,
+		displayValidation: validation.displayValidation,
+		updateValidation: validation.updateValidation,
+		resetValidation: validation.resetValidation,
+		commitValidation: validation.commitValidation,
 		collection: listState.collection,
 		selectionManager: listState.selectionManager,
 		focusedKey: listState.focusedKey,
@@ -4447,11 +5616,11 @@ function createComboBoxState(props) {
 	const allowsCustomValue = () => getProps().allowsCustomValue ?? false;
 	const shouldCloseOnBlur = () => getProps().shouldCloseOnBlur ?? true;
 	const isMultiple = () => getProps().selectionMode === "multiple";
-	const [focusStrategy, setFocusStrategy] = createSignal(null);
-	const [showAllItems, setShowAllItems] = createSignal(false);
+	const [focusStrategy, setFocusStrategy] = createInternalSignal(null);
+	const [showAllItems, setShowAllItems] = createInternalSignal(false);
 	let menuOpenTrigger = "focus";
 	const isMultiSelectionControlled = () => getProps().selectedKeys !== void 0;
-	const [internalSelectedKeys, setInternalSelectedKeys] = createSignal(new Set(getProps().defaultSelectedKeys ?? []));
+	const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal(new Set(getProps().defaultSelectedKeys ?? []));
 	const selectedKeys = () => {
 		return isMultiSelectionControlled() ? new Set(getProps().selectedKeys ?? []) : internalSelectedKeys();
 	};
@@ -4460,9 +5629,9 @@ function createComboBoxState(props) {
 		getProps().onSelectionChangeMultiple?.(keys);
 	};
 	const isSelectionControlled = () => getProps().selectedKey !== void 0;
-	const [internalSelectedKey, setInternalSelectedKey] = createSignal(getProps().defaultSelectedKey ?? null);
+	const [internalSelectedKey, setInternalSelectedKey] = createInternalSignal(getProps().defaultSelectedKey ?? null);
 	const isInputControlled = () => getProps().inputValue !== void 0;
-	const [internalInputValue, setInternalInputValue] = createSignal(getProps().defaultInputValue ?? "");
+	const [internalInputValue, setInternalInputValue] = createInternalSignal(getProps().defaultInputValue ?? "");
 	let inputInitialized = false;
 	const inputValue = () => {
 		return isInputControlled() ? getProps().inputValue ?? "" : internalInputValue();
@@ -4471,7 +5640,7 @@ function createComboBoxState(props) {
 		if (!isInputControlled()) setInternalInputValue(value);
 		getProps().onInputChange?.(value);
 	};
-	const [lastValue, setLastValue] = createSignal(inputValue());
+	const [lastValue, setLastValue] = createInternalSignal(inputValue());
 	const selectedKey = () => {
 		return isSelectionControlled() ? getProps().selectedKey ?? null : internalSelectedKey();
 	};
@@ -4479,6 +5648,7 @@ function createComboBoxState(props) {
 		if (!isSelectionControlled()) setInternalSelectedKey(key);
 		getProps().onSelectionChange?.(key);
 	};
+	let listState;
 	const overlayState = createOverlayTriggerState({
 		get isOpen() {
 			return getProps().isOpen;
@@ -4488,9 +5658,11 @@ function createComboBoxState(props) {
 		},
 		onOpenChange(isOpen) {
 			getProps().onOpenChange?.(isOpen, isOpen ? menuOpenTrigger : void 0);
+			listState?.setFocused(isOpen);
+			if (!isOpen) listState?.setFocusedKey(null);
 		}
 	});
-	const listState = createListState({
+	listState = createListState({
 		get items() {
 			return getProps().items ?? getProps().defaultItems ?? [];
 		},
@@ -4518,7 +5690,8 @@ function createComboBoxState(props) {
 		onSelectionChange(keys) {
 			if (keys === "all") return;
 			if (isMultiple()) {
-				setSelectedKeys(new Set(keys));
+				const newKeys = new Set(keys);
+				setSelectedKeys(newKeys);
 				return;
 			}
 			const key = keys.size > 0 ? Array.from(keys)[0] : null;
@@ -4533,10 +5706,9 @@ function createComboBoxState(props) {
 	const originalCollection = listState.collection;
 	const filteredCollection = createMemo(() => {
 		const collection = originalCollection();
-		const input = inputValue();
 		const filter = getProps().defaultFilter;
-		if (!filter) return collection;
-		return filterCollection(collection, input, filter);
+		if (getProps().items != null || !filter) return collection;
+		return filterCollection(collection, inputValue(), filter);
 	});
 	const displayedCollection = createMemo(() => {
 		return showAllItems() ? originalCollection() : filteredCollection();
@@ -4585,8 +5757,9 @@ function createComboBoxState(props) {
 		const displayAll = trigger === "manual" || trigger === "focus" && menuTrigger() === "focus";
 		const filtered = filteredCollection();
 		const original = originalCollection();
-		if (!(allowsEmptyCollection() || filtered.size > 0 || displayAll && original.size > 0)) return;
-		if (displayAll && !overlayState.isOpen()) setShowAllItems(true);
+		const items = getProps().items;
+		if (!(allowsEmptyCollection() || filtered.size > 0 || displayAll && original.size > 0 || items != null)) return;
+		if (displayAll && !overlayState.isOpen() && items === void 0) setShowAllItems(true);
 		menuOpenTrigger = trigger ?? "focus";
 		setFocusStrategy(strategy);
 		if (!overlayState.isOpen()) applyOpenFocus(strategy);
@@ -4596,9 +5769,10 @@ function createComboBoxState(props) {
 		const displayAll = trigger === "manual" || trigger === "focus" && menuTrigger() === "focus";
 		const filtered = filteredCollection();
 		const original = originalCollection();
-		if (!(allowsEmptyCollection() || filtered.size > 0 || displayAll && original.size > 0) && !overlayState.isOpen()) return;
+		const items = getProps().items;
+		if (!(allowsEmptyCollection() || filtered.size > 0 || displayAll && original.size > 0 || items != null) && !overlayState.isOpen()) return;
 		const willOpen = !overlayState.isOpen();
-		if (displayAll && willOpen) setShowAllItems(true);
+		if (displayAll && willOpen && items === void 0) setShowAllItems(true);
 		if (willOpen) menuOpenTrigger = trigger ?? "focus";
 		setFocusStrategy(strategy);
 		if (willOpen) applyOpenFocus(strategy);
@@ -4611,7 +5785,8 @@ function createComboBoxState(props) {
 	const commitSelection = () => {
 		if (isSelectionControlled() && isInputControlled()) {
 			getProps().onSelectionChange?.(selectedKey());
-			setLastValue(selectedItem()?.textValue ?? "");
+			const item = selectedItem();
+			setLastValue(item?.textValue ?? "");
 			closeMenu();
 		} else {
 			resetInputValue();
@@ -4631,56 +5806,66 @@ function createComboBoxState(props) {
 			if (overlayState.isOpen() && focusedKey != null) select(focusedKey);
 			return;
 		}
-		if (overlayState.isOpen() && focusedKey != null) if (selectedKey() === focusedKey) commitSelection();
-		else {
-			setSelectedKey(focusedKey);
-			closeMenu();
-		}
-		else commitValue();
+		if (overlayState.isOpen() && focusedKey != null) {
+			if (selectedKey() === focusedKey) commitSelection();
+			else listState.selectionManager.select(focusedKey);
+		} else commitValue();
 	};
 	const revert = () => {
 		if (allowsCustomValue() && selectedKey() == null) commitCustomValue();
 		else commitSelection();
 	};
-	const [isFocused, setIsFocused] = createSignal(false);
+	const [isFocused, setIsFocused] = createInternalSignal(false);
 	const setFocused = (focused) => {
 		if (focused) {
-			inputValue();
 			if (menuTrigger() === "focus" && !getProps().isReadOnly) open(null, "focus");
 		} else if (shouldCloseOnBlur()) commitValue();
 		setIsFocused(focused);
 	};
-	createEffect(() => {
-		const input = inputValue();
-		const filtered = filteredCollection();
-		const isOpen = overlayState.isOpen();
-		const last = lastValue();
-		if (isFocused() && (filtered.size > 0 || allowsEmptyCollection()) && !isOpen && input !== last && menuTrigger() !== "manual") open(null, "input");
-		if (!showAllItems() && !allowsEmptyCollection() && isOpen && filtered.size === 0) closeMenu();
+	let lastDisplayValue = untrack(selectedKey);
+	createEffect(() => ({
+		input: inputValue(),
+		filtered: filteredCollection(),
+		isOpen: overlayState.isOpen(),
+		last: lastValue(),
+		focused: isFocused(),
+		key: isMultiple() ? null : selectedKey(),
+		allowsEmpty: allowsEmptyCollection(),
+		trigger: menuTrigger(),
+		showingAll: showAllItems(),
+		inputControlled: isInputControlled(),
+		selectionControlled: isSelectionControlled()
+	}), ({ input, filtered, isOpen, last, focused, key, allowsEmpty, trigger, showingAll, inputControlled, selectionControlled }) => {
+		if (focused && (filtered.size > 0 || allowsEmpty) && !isOpen && input !== last && trigger !== "manual") open(null, "input");
+		if (!showingAll && !allowsEmpty && isOpen && filtered.size === 0) closeMenu();
+		if (key != null && key !== lastDisplayValue) closeMenu();
 		if (input !== last) {
 			listState.setFocusedKey(null);
 			setShowAllItems(false);
-			if (input === "" && (!isInputControlled() || !isSelectionControlled())) setSelectedKey(null);
+			if (input === "" && (!inputControlled || !selectionControlled)) setSelectedKey(null);
 			setLastValue(input);
 		}
+		lastDisplayValue = key;
 	});
 	createEffect(() => {
-		if (isMultiple()) return;
+		if (isMultiple()) return null;
 		const key = selectedKey();
-		const textValue = (key != null ? originalCollection().getItem(key) : null)?.textValue ?? "";
-		if (!isInputControlled() || !isSelectionControlled()) {
+		return {
+			key,
+			textValue: (key != null ? originalCollection().getItem(key) : null)?.textValue ?? "",
+			inputControlled: isInputControlled(),
+			selectionControlled: isSelectionControlled()
+		};
+	}, (data) => {
+		if (!data) return;
+		const { key, textValue, inputControlled, selectionControlled } = data;
+		if (!inputControlled || !selectionControlled) {
 			if (key != null && textValue !== untrack(inputValue)) {
 				setInputValue(textValue);
 				setLastValue(textValue);
 			}
 		}
 	});
-	createEffect((prevKey) => {
-		if (isMultiple()) return void 0;
-		const key = selectedKey();
-		if (key != null && key !== prevKey) closeMenu();
-		return key;
-	}, void 0);
 	const select = (key) => {
 		if (isMultiple()) {
 			const current = new Set(selectedKeys());
@@ -4715,6 +5900,7 @@ function createComboBoxState(props) {
 		selectedItem,
 		setSelectedKey,
 		selectedKeys,
+		setSelectedKeys,
 		selectedItems,
 		removeSelectedKey,
 		inputValue,
@@ -4745,101 +5931,39 @@ function createComboBoxState(props) {
 }
 /**
 * Filter a collection based on input value.
+* RAC `useComboBoxState.ts:644-672` copies nodes into a new `ListCollection`,
+* which reassigns `index` (ListCollection.ts:51-53). Keeping the original
+* `index` makes virtualized `aria-posinset` report the unfiltered position.
 */
 function filterCollection(collection, inputValue, filter) {
 	if (!inputValue) return collection;
 	const filteredItems = [];
+	let index = 0;
 	for (const item of collection) if (item.type === "section") {
 		const filteredChildren = [];
 		if (item.childNodes) {
-			for (const child of item.childNodes) if (child.type === "item" && filter(child.textValue, inputValue)) filteredChildren.push(child);
+			for (const child of item.childNodes) if (child.type === "item" && filter(child.textValue, inputValue)) filteredChildren.push({
+				...child,
+				index: index++
+			});
 		}
 		if (filteredChildren.length > 0) filteredItems.push({
 			...item,
 			childNodes: filteredChildren
 		});
 	} else if (item.type === "item") {
-		if (filter(item.textValue, inputValue)) filteredItems.push(item);
-	}
-	return createFilteredCollection(filteredItems, collection);
-}
-/**
-* Create a filtered collection wrapper.
-*/
-function createFilteredCollection(items, original) {
-	const itemMap = /* @__PURE__ */ new Map();
-	for (const item of items) {
-		itemMap.set(item.key, item);
-		if (item.childNodes) for (const child of item.childNodes) itemMap.set(child.key, child);
-	}
-	return {
-		get size() {
-			let count = 0;
-			for (const item of items) if (item.type === "item") count++;
-			else if (item.childNodes) count += Array.from(item.childNodes).filter((c) => c.type === "item").length;
-			return count;
-		},
-		getItem(key) {
-			return itemMap.get(key) ?? null;
-		},
-		getKeys() {
-			return itemMap.keys();
-		},
-		getFirstKey() {
-			for (const item of items) {
-				if (item.type === "item") return item.key;
-				if (item.childNodes) {
-					for (const child of item.childNodes) if (child.type === "item") return child.key;
-				}
-			}
-			return null;
-		},
-		getLastKey() {
-			for (let i = items.length - 1; i >= 0; i--) {
-				const item = items[i];
-				if (item.type === "item") return item.key;
-				if (item.childNodes) {
-					const children = Array.from(item.childNodes);
-					for (let j = children.length - 1; j >= 0; j--) if (children[j].type === "item") return children[j].key;
-				}
-			}
-			return null;
-		},
-		getKeyBefore(key) {
-			return original.getKeyBefore(key);
-		},
-		getKeyAfter(key) {
-			return original.getKeyAfter(key);
-		},
-		at(index) {
-			let currentIndex = 0;
-			for (const item of items) if (item.type === "item") {
-				if (currentIndex === index) return item;
-				currentIndex++;
-			} else if (item.childNodes) {
-				for (const child of item.childNodes) if (child.type === "item") {
-					if (currentIndex === index) return child;
-					currentIndex++;
-				}
-			}
-			return null;
-		},
-		getChildren(key) {
-			return itemMap.get(key)?.childNodes ?? [];
-		},
-		getTextValue(key) {
-			return itemMap.get(key)?.textValue ?? "";
-		},
-		[Symbol.iterator]() {
-			return items[Symbol.iterator]();
-		}
-	};
+		if (filter(item.textValue, inputValue)) filteredItems.push({
+			...item,
+			index: index++
+		});
+	} else filteredItems.push({ ...item });
+	return new ListCollection(filteredItems);
 }
 //#endregion
 //#region src/tabs/createTabListState.ts
 /**
 * State management for tab components.
-* Based on @react-stately/tabs.
+* Ported from packages/react-stately/src/tabs/useTabListState.ts.
 */
 /**
 * Creates state for a tab list component.
@@ -4888,7 +6012,7 @@ function createTabListState(props) {
 		if (p.defaultSelectedKey !== void 0 && !isKeyDisabled(p.defaultSelectedKey)) return p.defaultSelectedKey;
 		return findFirstNonDisabledKey();
 	};
-	const [selectedKeyInternal, setSelectedKeyInternal] = createSignal(getInitialSelectedKey());
+	const [selectedKeyInternal, setSelectedKeyInternal] = createInternalSignal(getInitialSelectedKey());
 	const selectedKey = () => {
 		const p = getProps();
 		if (p.selectedKey !== void 0) return p.selectedKey;
@@ -4909,33 +6033,55 @@ function createTabListState(props) {
 	const isDisabled = () => getProps().isDisabled ?? false;
 	const keyboardActivation = () => getProps().keyboardActivation ?? "automatic";
 	const orientation = () => getProps().orientation ?? "horizontal";
-	const [isFocused, setIsFocused] = createSignal(false);
-	const [focusedKey, setFocusedKeyInternal] = createSignal(null);
-	const [childFocusStrategy, setChildFocusStrategy] = createSignal(null);
+	const [isFocused, setIsFocused] = createInternalSignal(false);
+	const [focusedKey, setFocusedKeyInternal] = createInternalSignal(null);
+	const [childFocusStrategy, setChildFocusStrategy] = createInternalSignal(null);
 	const setFocusedKey = (key, childStrategy) => {
 		setFocusedKeyInternal(key);
 		setChildFocusStrategy(childStrategy ?? null);
 	};
 	let lastSelectedKey = selectedKey();
-	createComputed(() => {
+	let selectedToFocusedFrame = null;
+	const copySelectedToFocusedKey = () => {
+		selectedToFocusedFrame = null;
 		const sel = selectedKey();
 		if (sel !== null && focusedKey() === null || !isFocused() && sel !== lastSelectedKey) setFocusedKey(sel);
 		lastSelectedKey = sel;
+	};
+	createEffect(() => ({
+		sel: selectedKey(),
+		foc: focusedKey(),
+		focused: isFocused()
+	}), ({ sel, foc, focused }) => {
+		if (sel !== null && foc === null) {
+			setFocusedKey(sel);
+			lastSelectedKey = sel;
+			return;
+		}
+		if (!focused && sel !== lastSelectedKey) {
+			if (selectedToFocusedFrame != null) return;
+			selectedToFocusedFrame = requestAnimationFrame(copySelectedToFocusedKey);
+		}
+	});
+	onCleanup(() => {
+		if (selectedToFocusedFrame == null) return;
+		cancelAnimationFrame(selectedToFocusedFrame);
+		selectedToFocusedFrame = null;
 	});
-	createComputed(() => {
+	createEffect(() => {
 		const p = getProps();
-		if (p.selectedKey !== void 0) return;
+		if (p.selectedKey !== void 0) return void 0;
 		const coll = collection();
+		if (coll.size === 0) return void 0;
 		const current = selectedKeyInternal();
 		const currentExists = current !== null && coll.getItem(current) !== null;
 		const currentEnabled = current !== null && !isKeyDisabled(current);
-		if (currentExists && currentEnabled) return;
-		if (p.defaultSelectedKey !== void 0 && coll.getItem(p.defaultSelectedKey) !== null && !isKeyDisabled(p.defaultSelectedKey)) {
-			if (p.defaultSelectedKey !== current) setSelectedKeyInternal(p.defaultSelectedKey);
-			return;
-		}
+		if (currentExists && currentEnabled) return void 0;
+		if (p.defaultSelectedKey !== void 0 && coll.getItem(p.defaultSelectedKey) !== null && !isKeyDisabled(p.defaultSelectedKey)) return p.defaultSelectedKey !== current ? p.defaultSelectedKey : void 0;
 		const nextKey = findFirstNonDisabledKey();
-		if (nextKey !== current) setSelectedKeyInternal(nextKey);
+		return nextKey !== current ? nextKey : void 0;
+	}, (nextKey) => {
+		if (nextKey !== void 0) setSelectedKeyInternal(nextKey);
 	});
 	return {
 		collection,
@@ -5000,50 +6146,60 @@ function isValidStep(step) {
 */
 function createNumberFieldState(props) {
 	const getProps = () => access(props);
+	const [inputValue, setInputValueInternal] = createInternalSignal("");
+	const [numberValue, setNumberValue] = createInternalSignal(NaN);
 	const locale = () => getProps().locale ?? "en-US";
 	const formatOptions = () => getProps().formatOptions ?? {};
+	const numberParser = createMemo(() => {
+		return new NumberParser(locale(), formatOptions());
+	});
+	const numberingSystem = createMemo(() => {
+		return numberParser().getNumberingSystem(inputValue());
+	});
 	const formatter = createMemo(() => {
-		return new Intl.NumberFormat(locale(), formatOptions());
+		return new NumberFormatter(locale(), {
+			...formatOptions(),
+			numberingSystem: numberingSystem()
+		});
 	});
 	const parseNumber = (value) => {
-		if (!value || value === "" || value === "-") return NaN;
-		const opts = formatOptions();
-		const decimalSeparator = formatter().format(1.1).charAt(1);
-		let normalized = value;
-		if (decimalSeparator !== ".") normalized = normalized.replace(decimalSeparator, ".");
-		normalized = normalized.replace(/[^\d.-]/g, "");
-		const parsed = parseFloat(normalized);
-		if (isNaN(parsed)) return parsed;
-		if (opts.style === "percent") return parsed / 100;
-		return parsed;
+		return numberParser().parse(value);
 	};
 	const formatNumber = (value) => {
-		if (isNaN(value)) return "";
+		if (isNaN(value) || value === null) return "";
 		return formatter().format(value);
 	};
 	const hasCustomStep = createMemo(() => isValidStep(getProps().step));
+	const shouldSnap = () => (getProps().commitBehavior ?? "snap") === "snap";
 	const step = createMemo(() => {
 		const p = getProps();
 		if (hasCustomStep()) return p.step;
-		if (p.formatOptions?.style === "percent") return .01;
+		if (formatter().resolvedOptions().style === "percent") return .01;
 		return 1;
 	});
-	const [inputValue, setInputValueInternal] = createSignal("");
-	const [numberValue, setNumberValue] = createSignal(NaN);
 	const applyConstraints = (value) => {
 		const p = getProps();
 		if (isNaN(value)) return NaN;
 		if (hasCustomStep()) return clamp$2(snapToStep$1(value, step(), p.minValue), p.minValue, p.maxValue);
 		return clamp$2(value, p.minValue, p.maxValue);
 	};
+	let initialNumberValue = NaN;
+	let capturedDefaultNumberValue = NaN;
+	const constrainForCommit = (value) => {
+		if (!shouldSnap()) return value;
+		return applyConstraints(value);
+	};
 	const initValue = () => {
 		const p = getProps();
 		const initial = p.value ?? p.defaultValue;
-		if (initial != null) {
-			const constrained = applyConstraints(initial);
-			setNumberValue(constrained);
-			setInputValueInternal(formatNumber(constrained));
-		}
+		if (initial != null && !isNaN(initial)) {
+			const next = constrainForCommit(initial);
+			setNumberValue(next);
+			setInputValueInternal(formatNumber(next));
+			initialNumberValue = next;
+		} else initialNumberValue = NaN;
+		const defaultValue = p.defaultValue ?? NaN;
+		capturedDefaultNumberValue = isNaN(defaultValue) ? initialNumberValue : constrainForCommit(defaultValue);
 	};
 	let initialized = false;
 	const ensureInitialized = () => {
@@ -5055,7 +6211,7 @@ function createNumberFieldState(props) {
 	const actualNumberValue = createMemo(() => {
 		ensureInitialized();
 		const p = getProps();
-		if (p.value !== void 0) return applyConstraints(p.value);
+		if (p.value !== void 0) return constrainForCommit(p.value);
 		return numberValue();
 	});
 	let lastControlledValue = void 0;
@@ -5065,23 +6221,41 @@ function createNumberFieldState(props) {
 			lastControlledValue = void 0;
 			return;
 		}
-		const constrained = applyConstraints(p.value);
-		if (lastControlledValue === void 0 || !Object.is(lastControlledValue, constrained)) {
-			lastControlledValue = constrained;
-			setNumberValue(constrained);
-			setInputValueInternal(formatNumber(constrained));
+		const next = constrainForCommit(p.value);
+		if (lastControlledValue === void 0 || !Object.is(lastControlledValue, next)) {
+			lastControlledValue = next;
+			setNumberValue(next);
+			setInputValueInternal(formatNumber(next));
 		}
 	};
 	const parsedInputValue = () => {
 		ensureInitialized();
 		syncControlledValue();
-		return parseNumber(inputValue());
+		return parseNumber(readNow(inputValue));
 	};
+	const validation = createFormValidationState({
+		get value() {
+			ensureInitialized();
+			return actualNumberValue();
+		},
+		get isInvalid() {
+			return getProps().isInvalid;
+		},
+		get validationState() {
+			return getProps().validationState;
+		},
+		get validate() {
+			return getProps().validate;
+		},
+		get name() {
+			return getProps().name;
+		},
+		get validationBehavior() {
+			return getProps().validationBehavior ?? "native";
+		}
+	});
 	const validate = (value) => {
-		if (value === "" || value === "-") return true;
-		formatOptions();
-		const decimalSeparator = formatter().format(1.1).charAt(1);
-		return new RegExp(`^-?\\d*${decimalSeparator === "." ? "\\." : decimalSeparator}?\\d*$`).test(value);
+		return numberParser().isValidPartialNumber(value, getProps().minValue, getProps().maxValue);
 	};
 	const setInputValue = (value) => {
 		ensureInitialized();
@@ -5091,22 +6265,26 @@ function createNumberFieldState(props) {
 	const commit = () => {
 		ensureInitialized();
 		const p = getProps();
-		const input = inputValue();
+		const input = readNow(inputValue);
 		if (input === "" || input === "-") {
 			setNumberValue(NaN);
-			setInputValueInternal(p.value === void 0 ? "" : formatNumber(actualNumberValue()));
+			setInputValueInternal(p.value === void 0 ? "" : formatNumber(readNow(actualNumberValue)));
 			p.onChange?.(NaN);
+			validation.commitValidation();
 			return;
 		}
 		let parsed = parseNumber(input);
 		if (isNaN(parsed)) {
-			setInputValueInternal(formatNumber(actualNumberValue()));
+			setInputValueInternal(formatNumber(readNow(actualNumberValue)));
 			return;
 		}
-		parsed = applyConstraints(parsed);
+		const previous = readNow(actualNumberValue);
+		parsed = constrainForCommit(parsed);
+		parsed = numberParser().parse(formatNumber(parsed));
 		setNumberValue(parsed);
 		setInputValueInternal(formatNumber(parsed));
 		p.onChange?.(parsed);
+		if (parsed !== previous) validation.commitValidation();
 	};
 	const canIncrement = createMemo(() => {
 		ensureInitialized();
@@ -5143,6 +6321,7 @@ function createNumberFieldState(props) {
 		setNumberValue(current);
 		setInputValueInternal(formatNumber(current));
 		p.onChange?.(current);
+		validation.commitValidation();
 	};
 	const decrement = () => {
 		ensureInitialized();
@@ -5153,6 +6332,7 @@ function createNumberFieldState(props) {
 		setNumberValue(current);
 		setInputValueInternal(formatNumber(current));
 		p.onChange?.(current);
+		validation.commitValidation();
 	};
 	const incrementToMax = () => {
 		ensureInitialized();
@@ -5164,6 +6344,7 @@ function createNumberFieldState(props) {
 		setNumberValue(snapped);
 		setInputValueInternal(formatNumber(snapped));
 		p.onChange?.(snapped);
+		validation.commitValidation();
 	};
 	const decrementToMin = () => {
 		ensureInitialized();
@@ -5174,8 +6355,20 @@ function createNumberFieldState(props) {
 		setNumberValue(p.minValue);
 		setInputValueInternal(formatNumber(p.minValue));
 		p.onChange?.(p.minValue);
+		validation.commitValidation();
+	};
+	const setNumberValuePublic = (value) => {
+		ensureInitialized();
+		setNumberValue(value);
+		setInputValueInternal(formatNumber(value));
+		getProps().onChange?.(value);
 	};
 	return {
+		realtimeValidation: validation.realtimeValidation,
+		displayValidation: validation.displayValidation,
+		updateValidation: validation.updateValidation,
+		resetValidation: validation.resetValidation,
+		commitValidation: validation.commitValidation,
 		get inputValue() {
 			ensureInitialized();
 			syncControlledValue();
@@ -5190,6 +6383,12 @@ function createNumberFieldState(props) {
 		isReadOnly: () => getProps().isReadOnly ?? false,
 		minValue: () => getProps().minValue,
 		maxValue: () => getProps().maxValue,
+		step: () => getProps().step,
+		get defaultNumberValue() {
+			ensureInitialized();
+			return capturedDefaultNumberValue;
+		},
+		setNumberValue: setNumberValuePublic,
 		setInputValue,
 		validate,
 		commit,
@@ -5211,7 +6410,7 @@ function createNumberFieldState(props) {
 function createSearchFieldState(props) {
 	const getProps = () => access(props);
 	const isControlled = () => getProps().value !== void 0;
-	const [internalValue, setInternalValue] = createSignal(getProps().defaultValue ?? "");
+	const [internalValue, setInternalValue] = createInternalSignal(getProps().defaultValue ?? "");
 	const value = createMemo(() => {
 		const p = getProps();
 		return isControlled() ? p.value ?? "" : internalValue();
@@ -5265,9 +6464,9 @@ function createSliderState(props) {
 	const isDisabled = createMemo(() => getProps().isDisabled ?? false);
 	const pageStep = createMemo(() => Math.max(step(), snapToStep((maxValue() - minValue()) / 10, 0, maxValue() - minValue(), step())));
 	const isControlled = () => getProps().value !== void 0;
-	const [internalValue, setInternalValue] = createSignal(snapToStep(initialProps.defaultValue ?? initialMinValue, initialMinValue, initialMaxValue, initialStep));
-	const [isDragging, setIsDragging] = createSignal(false);
-	const [isFocused, setIsFocused] = createSignal(false);
+	const [internalValue, setInternalValue] = createInternalSignal(snapToStep(initialProps.defaultValue ?? initialMinValue, initialMinValue, initialMaxValue, initialStep));
+	const [isDragging, setIsDragging] = createInternalSignal(false);
+	const [isFocused, setIsFocused] = createInternalSignal(false);
 	const value = createMemo(() => {
 		const p = getProps();
 		return snapToStep(isControlled() ? p.value ?? minValue() : internalValue(), minValue(), maxValue(), step());
@@ -5287,7 +6486,8 @@ function createSliderState(props) {
 		p.onChange?.(snappedValue);
 	};
 	const setValuePercent = (percent) => {
-		setValue(clamp$1(percent, 0, 1) * (maxValue() - minValue()) + minValue());
+		const newValue = clamp$1(percent, 0, 1) * (maxValue() - minValue()) + minValue();
+		setValue(newValue);
 	};
 	const setDragging = (dragging) => {
 		const wasDragging = isDragging();
@@ -5380,26 +6580,31 @@ function createTooltipTriggerState(props = {}) {
 	const closeDelay = () => props.closeDelay ?? TOOLTIP_COOLDOWN;
 	const overlayState = createOverlayTriggerState(props);
 	const id = `tooltip-${++tooltipId}`;
+	const [shouldSkipAnimation, setShouldSkipAnimation] = createInternalSignal(false);
 	let closeTimeout = null;
-	const [closeCallback, setCloseCallback] = createSignal(() => overlayState.close());
+	let closeFn = overlayState.close;
 	const ensureTooltipEntry = () => {
 		tooltips[id] = hideTooltip;
 	};
 	const closeOpenTooltips = () => {
 		for (const hideTooltipId in tooltips) if (hideTooltipId !== id) {
-			tooltips[hideTooltipId](true);
+			tooltips[hideTooltipId](true, true);
 			delete tooltips[hideTooltipId];
 		}
 	};
-	const showTooltip = () => {
+	const showTooltip = (instant) => {
 		if (closeTimeout) {
 			clearTimeout(closeTimeout);
 			closeTimeout = null;
 		}
 		closeOpenTooltips();
 		ensureTooltipEntry();
+		setShouldSkipAnimation(!!instant);
 		globalWarmedUp = true;
 		overlayState.open();
+		try {
+			flush();
+		} catch {}
 		if (globalWarmUpTimeout) {
 			clearTimeout(globalWarmUpTimeout);
 			globalWarmUpTimeout = null;
@@ -5409,16 +6614,17 @@ function createTooltipTriggerState(props = {}) {
 			globalCooldownTimeout = null;
 		}
 	};
-	const hideTooltip = (immediate) => {
+	const hideTooltip = (immediate, instant) => {
+		setShouldSkipAnimation(!!instant);
 		if (immediate || closeDelay() <= 0) {
 			if (closeTimeout) {
 				clearTimeout(closeTimeout);
 				closeTimeout = null;
 			}
-			closeCallback()();
+			closeFn();
 		} else if (!closeTimeout) closeTimeout = setTimeout(() => {
 			closeTimeout = null;
-			closeCallback()();
+			closeFn();
 		}, closeDelay());
 		if (globalWarmUpTimeout) {
 			clearTimeout(globalWarmUpTimeout);
@@ -5439,21 +6645,22 @@ function createTooltipTriggerState(props = {}) {
 		if (!overlayState.isOpen() && !globalWarmUpTimeout && !globalWarmedUp) globalWarmUpTimeout = setTimeout(() => {
 			globalWarmUpTimeout = null;
 			globalWarmedUp = true;
-			showTooltip();
+			showTooltip(false);
 		}, delay());
-		else if (!overlayState.isOpen()) showTooltip();
+		else if (!overlayState.isOpen()) showTooltip(true);
 	};
-	setCloseCallback(() => overlayState.close);
+	closeFn = overlayState.close;
 	onCleanup(() => {
 		if (closeTimeout) clearTimeout(closeTimeout);
 		if (tooltips[id]) delete tooltips[id];
 	});
 	return {
 		isOpen: overlayState.isOpen,
+		shouldSkipAnimation,
 		open: (immediate) => {
 			if (isServer) return;
 			if (!immediate && delay() > 0 && !closeTimeout) warmupTooltip();
-			else showTooltip();
+			else showTooltip(true);
 		},
 		close: hideTooltip
 	};
@@ -5652,15 +6859,18 @@ var ToastQueue = class {
 * Use this hook to subscribe to toast changes in your component.
 */
 function createToastState(props) {
-	const [visibleToasts, setVisibleToasts] = createSignal([]);
+	const [visibleToasts, setVisibleToasts] = createInternalSignal([]);
 	const unsubscribe = props.queue.subscribe((toasts) => {
 		setVisibleToasts(toasts);
+		try {
+			flush();
+		} catch {}
 	});
 	onCleanup(() => {
 		unsubscribe();
 	});
 	return {
-		visibleToasts,
+		visibleToasts: () => readNow(visibleToasts),
 		add: (content, options) => props.queue.add(content, options),
 		close: (key) => props.queue.close(key),
 		remove: (key) => props.queue.remove(key),
@@ -5692,7 +6902,7 @@ function createToastQueue(options) {
 */
 function createDisclosureState(props = {}) {
 	const propsAccessor = () => access(props);
-	const [internalExpanded, setInternalExpanded] = createSignal(propsAccessor().defaultExpanded ?? false);
+	const [internalExpanded, setInternalExpanded] = createInternalSignal(propsAccessor().defaultExpanded ?? false);
 	const isExpanded = () => {
 		const p = propsAccessor();
 		return p.isExpanded !== void 0 ? p.isExpanded : internalExpanded();
@@ -5719,7 +6929,7 @@ function createDisclosureState(props = {}) {
 */
 function createDisclosureGroupState(props = {}) {
 	const propsAccessor = () => access(props);
-	const [internalKeys, setInternalKeys] = createSignal(new Set(propsAccessor().defaultExpandedKeys ?? []));
+	const [internalKeys, setInternalKeys] = createInternalSignal(new Set(propsAccessor().defaultExpandedKeys ?? []));
 	const expandedKeys = createMemo(() => {
 		const p = propsAccessor();
 		return p.expandedKeys !== void 0 ? new Set(p.expandedKeys) : internalKeys();
@@ -5730,18 +6940,22 @@ function createDisclosureGroupState(props = {}) {
 		p.onExpandedChange?.(keys);
 	};
 	createEffect(() => {
-		const allowsMultiple = propsAccessor().allowsMultipleExpanded ?? false;
-		const keys = expandedKeys();
+		return {
+			allowsMultiple: propsAccessor().allowsMultipleExpanded ?? false,
+			keys: expandedKeys()
+		};
+	}, ({ allowsMultiple, keys }) => {
 		if (!allowsMultiple && keys.size > 1) {
 			const firstKey = keys.values().next().value;
 			if (firstKey != null) queueMicrotask(() => {
-				setExpandedKeys(new Set([firstKey]));
+				setExpandedKeys(/* @__PURE__ */ new Set([firstKey]));
 			});
 		}
 	});
 	const toggleKey = (key) => {
-		const allowsMultiple = propsAccessor().allowsMultipleExpanded ?? false;
-		const currentKeys = expandedKeys();
+		const p = propsAccessor();
+		const allowsMultiple = p.allowsMultipleExpanded ?? false;
+		const currentKeys = p.expandedKeys !== void 0 ? expandedKeys() : readNow(internalKeys);
 		let newKeys;
 		if (allowsMultiple) {
 			newKeys = new Set(currentKeys);
@@ -5770,7 +6984,7 @@ function createDisclosureGroupState(props = {}) {
 //#region src/grid/createGridState.ts
 /**
 * Grid state management for Table and GridList components.
-* Based on @react-stately/grid/useGridState.
+* Based on packages/react-stately/src/grid/useGridState.ts.
 */
 /**
 * Creates state management for a grid component.
@@ -5782,30 +6996,33 @@ function createGridState(options) {
 		const keys = getOptions().disabledKeys;
 		return keys ? new Set(keys) : /* @__PURE__ */ new Set();
 	});
-	const [isFocused, setIsFocused] = createSignal(false);
-	const [focusedKey, setFocusedKeyInternal] = createSignal(null);
-	const [childFocusStrategy, setChildFocusStrategy] = createSignal(null);
-	const [isKeyboardNavigationDisabled, setKeyboardNavigationDisabled] = createSignal(false);
-	const [internalSelectedKeys, setInternalSelectedKeys] = createSignal(getInitialSelection$1(getOptions().defaultSelectedKeys));
-	const [anchorKey, setAnchorKey] = createSignal(null);
-	const selectedKeys = createMemo(() => {
+	const [isFocused, setIsFocused] = createInternalSignal(false);
+	const [focusedKey, setFocusedKeyInternal] = createInternalSignal(null);
+	const [childFocusStrategy, setChildFocusStrategy] = createInternalSignal(null);
+	const [isKeyboardNavigationDisabled, setKeyboardNavigationDisabled] = createInternalSignal(false);
+	const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal(getInitialSelection$1(getOptions().defaultSelectedKeys));
+	const [anchorKey, setAnchorKey] = createInternalSignal(null);
+	const selectedKeys = () => {
 		const opts = getOptions();
 		if (opts.selectedKeys !== void 0) return normalizeSelection$1(opts.selectedKeys);
 		return internalSelectedKeys();
-	});
+	};
 	const selectionMode = createMemo(() => getOptions().selectionMode ?? "none");
 	const selectionBehaviorProp = () => getOptions().selectionBehavior ?? "toggle";
-	const [selectionBehaviorState, setSelectionBehaviorState] = createSignal(selectionBehaviorProp());
+	const [selectionBehaviorState, setSelectionBehaviorState] = createInternalSignal(selectionBehaviorProp());
 	const selectionBehavior = createMemo(() => selectionBehaviorState());
 	const disallowEmptySelection = createMemo(() => getOptions().disallowEmptySelection ?? false);
 	const disabledBehavior = createMemo(() => getOptions().disabledBehavior ?? "all");
 	const focusMode = createMemo(() => getOptions().focusMode ?? "row");
-	createEffect(on(selectionBehaviorProp, (behavior) => {
+	createEffect(selectionBehaviorProp, (behavior) => {
 		setSelectionBehaviorState(behavior);
-	}));
-	createEffect(() => {
-		const keys = selectedKeys();
-		if (selectionBehaviorProp() === "replace" && selectionBehaviorState() === "toggle" && keys !== "all" && keys.size === 0) setSelectionBehaviorState("replace");
+	});
+	createEffect(() => ({
+		prop: selectionBehaviorProp(),
+		state: selectionBehaviorState(),
+		keys: selectedKeys()
+	}), ({ prop, state, keys }) => {
+		if (prop === "replace" && state === "toggle" && keys !== "all" && keys.size === 0) setSelectionBehaviorState("replace");
 	});
 	const setFocusedKey = (key, strategy = "first") => {
 		const collection = getOptions().collection;
@@ -5819,9 +7036,12 @@ function createGridState(options) {
 		setFocusedKeyInternal(key);
 		setChildFocusStrategy(strategy);
 	};
-	let cachedCollection = null;
-	createEffect(on(() => getOptions().collection, (collection) => {
-		const currentFocusedKey = focusedKey();
+	let cachedCollection = getOptions().collection;
+	createEffect(() => ({
+		collection: getOptions().collection,
+		currentFocusedKey: focusedKey(),
+		disabled: disabledKeys()
+	}), ({ collection, currentFocusedKey, disabled }) => {
 		if (currentFocusedKey != null && cachedCollection && !collection.getItem(currentFocusedKey)) {
 			const node = cachedCollection.getItem(currentFocusedKey);
 			const parentNode = node?.parentKey != null && (node.type === "cell" || node.type === "rowheader" || node.type === "column") ? cachedCollection.getItem(node.parentKey) : node;
@@ -5835,29 +7055,60 @@ function createGridState(options) {
 			const diff = cachedRows.length - rows.length;
 			let index = Math.min(diff > 1 ? Math.max(parentNode.index - diff + 1, 0) : parentNode.index, rows.length - 1);
 			let newRow = null;
-			while (index >= 0) {
-				const row = rows[index];
-				if (!disabledKeys().has(row.key) && row.type !== "headerrow") {
+			for (let i = Math.max(0, index); i < rows.length; i++) {
+				const row = rows[i];
+				if (!disabled.has(row.key) && row.type !== "headerrow") {
 					newRow = row;
 					break;
 				}
-				if (index < rows.length - 1) index++;
-				else {
-					if (index > parentNode.index) index = parentNode.index;
-					index--;
+			}
+			if (newRow === null) for (let i = index - 1; i >= 0; i--) {
+				const row = rows[i];
+				if (!disabled.has(row.key) && row.type !== "headerrow") {
+					newRow = row;
+					break;
 				}
 			}
 			if (newRow) {
 				const childNodes = newRow.hasChildNodes ? [...collection.getChildren(newRow.key)] : [];
-				setFocusedKeyInternal(newRow.hasChildNodes && parentNode !== node && node && node.index < childNodes.length ? childNodes[node.index].key : newRow.key);
+				const keyToFocus = newRow.hasChildNodes && parentNode !== node && node && node.index < childNodes.length ? childNodes[node.index].key : newRow.key;
+				setFocusedKeyInternal(keyToFocus);
 			} else setFocusedKeyInternal(null);
 		}
 		cachedCollection = collection;
-	}));
-	const isSelected = (key) => {
+	});
+	const getSelectionKey = (key) => {
+		const collection = getOptions().collection;
+		let item = collection.getItem(key);
+		if (!item) return key;
+		while (item && item.type !== "item" && item.parentKey != null) item = collection.getItem(item.parentKey);
+		return item?.type === "item" ? item.key : null;
+	};
+	const canSelectItem = (key) => {
+		if (selectionMode() === "none" || disabledKeys().has(key)) return false;
+		const item = getOptions().collection.getItem(key);
+		return !!item && item.type === "item" && !item.isDisabled && !item.props?.isDisabled;
+	};
+	const getSelectAllKeys = () => {
+		return getOptions().collection.rows.filter((row) => row.type === "item" && canSelectItem(row.key)).map((row) => row.key);
+	};
+	const isEmpty = createMemo(() => {
+		const keys = selectedKeys();
+		return keys !== "all" && keys.size === 0;
+	});
+	const isSelectAll = createMemo(() => {
 		const keys = selectedKeys();
+		if (isEmpty()) return false;
 		if (keys === "all") return true;
-		return keys.has(key);
+		return getSelectAllKeys().every((key) => keys.has(key));
+	});
+	const isSelected = (key) => {
+		if (selectionMode() === "none") return false;
+		const selectionKey = getSelectionKey(key);
+		if (selectionKey == null) return false;
+		const keys = selectedKeys();
+		if (keys === "all") return canSelectItem(selectionKey);
+		return keys.has(selectionKey);
 	};
 	const isDisabled = (key) => {
 		return disabledKeys().has(key);
@@ -5875,30 +7126,44 @@ function createGridState(options) {
 		}
 	};
 	const toggleSelection = (key) => {
-		if (isDisabled(key)) return;
 		if (selectionMode() === "none") return;
+		const selectionKey = getSelectionKey(key);
+		if (selectionKey == null) return;
 		const current = selectedKeys();
 		if (selectionMode() === "single") {
-			if (isSelected(key) && !disallowEmptySelection()) updateSelection(/* @__PURE__ */ new Set());
-			else updateSelection(new Set([key]));
+			if (isSelected(selectionKey) && !disallowEmptySelection()) updateSelection(/* @__PURE__ */ new Set());
+			else if (canSelectItem(selectionKey)) updateSelection(/* @__PURE__ */ new Set([selectionKey]));
 			return;
 		}
-		if (current === "all") return;
-		const newSelection = new Set(current);
-		if (newSelection.has(key)) {
-			if (newSelection.size > 1 || !disallowEmptySelection()) newSelection.delete(key);
-		} else newSelection.add(key);
+		const newSelection = new Set(current === "all" ? getSelectAllKeys() : current);
+		if (newSelection.has(selectionKey)) {
+			if (newSelection.size > 1 || !disallowEmptySelection()) newSelection.delete(selectionKey);
+		} else if (canSelectItem(selectionKey)) newSelection.add(selectionKey);
 		updateSelection(newSelection);
-		setAnchorKey(key);
+		setAnchorKey(selectionKey);
 	};
 	const replaceSelection = (key) => {
-		if (isDisabled(key)) return;
 		if (selectionMode() === "none") return;
-		updateSelection(new Set([key]));
-		setAnchorKey(key);
+		const selectionKey = getSelectionKey(key);
+		if (selectionKey == null) return;
+		updateSelection(canSelectItem(selectionKey) ? /* @__PURE__ */ new Set([selectionKey]) : /* @__PURE__ */ new Set());
+		setAnchorKey(selectionKey);
 	};
 	const setSelectedKeys = (keys) => {
-		updateSelection(normalizeSelection$1(keys));
+		if (selectionMode() === "none") return;
+		if (keys === "all") {
+			updateSelection("all");
+			return;
+		}
+		const selection = /* @__PURE__ */ new Set();
+		for (const key of keys) {
+			const selectionKey = getSelectionKey(key);
+			if (selectionKey != null) {
+				selection.add(selectionKey);
+				if (selectionMode() === "single") break;
+			}
+		}
+		updateSelection(selection);
 	};
 	const extendSelection = (toKey) => {
 		if (isDisabled(toKey)) return;
@@ -5906,7 +7171,7 @@ function createGridState(options) {
 			replaceSelection(toKey);
 			return;
 		}
-		const anchor = anchorKey();
+		const anchor = anchorKey() ?? focusedKey();
 		if (!anchor) {
 			replaceSelection(toKey);
 			return;
@@ -5925,7 +7190,7 @@ function createGridState(options) {
 	};
 	const selectAll = () => {
 		if (selectionMode() !== "multiple") return;
-		updateSelection("all");
+		if (!isSelectAll()) updateSelection("all");
 	};
 	const clearSelection = () => {
 		if (disallowEmptySelection()) return;
@@ -5933,7 +7198,7 @@ function createGridState(options) {
 	};
 	const toggleSelectAll = () => {
 		if (selectionMode() !== "multiple") return;
-		if (selectedKeys() === "all") clearSelection();
+		if (isSelectAll()) clearSelection();
 		else selectAll();
 	};
 	return {
@@ -5970,6 +7235,12 @@ function createGridState(options) {
 		get selectedKeys() {
 			return selectedKeys();
 		},
+		get isEmpty() {
+			return isEmpty();
+		},
+		get isSelectAll() {
+			return isSelectAll();
+		},
 		isSelected,
 		isDisabled,
 		setFocusedKey,
@@ -6073,6 +7344,12 @@ function createTableState(options) {
 		get selectedKeys() {
 			return gridState.selectedKeys;
 		},
+		get isEmpty() {
+			return gridState.isEmpty;
+		},
+		get isSelectAll() {
+			return gridState.isSelectAll;
+		},
 		isSelected: gridState.isSelected,
 		isDisabled: gridState.isDisabled,
 		setFocusedKey: gridState.setFocusedKey,
@@ -6229,7 +7506,7 @@ var TableCollection = class {
 			return !!(col.props?.columnDefinition)?.isRowHeader;
 		}).map((col) => col.key);
 		if (explicitRowHeaderKeys.length > 0) return new Set(explicitRowHeaderKeys);
-		for (const col of this._columns) if (col.key !== "__selection__") return new Set([col.key]);
+		for (const col of this._columns) if (col.key !== "__selection__") return /* @__PURE__ */ new Set([col.key]);
 		return /* @__PURE__ */ new Set();
 	}
 	/** Counts the leaf columns supplied by the user (excludes the selection column). */
@@ -6483,12 +7760,12 @@ function createTableCollection(options) {
 */
 function createTreeGridState(options) {
 	const getOptions = () => options();
-	const [internalExpandedKeys, setInternalExpandedKeys] = createSignal(getInitialExpanded(getOptions().UNSTABLE_defaultExpandedKeys));
-	const expandedKeys = createMemo(() => {
+	const [internalExpandedKeys, setInternalExpandedKeys] = createInternalSignal(getInitialExpanded(getOptions().UNSTABLE_defaultExpandedKeys));
+	const expandedKeys = () => {
 		const controlled = getOptions().UNSTABLE_expandedKeys;
 		if (controlled !== void 0) return convertExpanded(controlled);
 		return internalExpandedKeys();
-	});
+	};
 	const collection = createMemo(() => createTableCollection({
 		columns: getOptions().columns,
 		rows: getOptions().rows,
@@ -6661,8 +7938,8 @@ function distributeWidths(columns, tableWidth) {
 function createTableColumnResizeState(props) {
 	const getProps = () => props();
 	const initialWidths = createMemo(() => distributeWidths(getProps().columns, getProps().tableWidth));
-	const [overrides, setOverrides] = createSignal(/* @__PURE__ */ new Map());
-	const [resizingColumn, setResizingColumn] = createSignal(null);
+	const [overrides, setOverrides] = createInternalSignal(/* @__PURE__ */ new Map());
+	const [resizingColumn, setResizingColumn] = createInternalSignal(null);
 	const columnWidths = createMemo(() => {
 		const base = initialWidths();
 		const over = overrides();
@@ -6737,44 +8014,52 @@ function createTreeState(options) {
 		const keys = getOptions().disabledKeys;
 		return keys ? new Set(keys) : /* @__PURE__ */ new Set();
 	});
-	const [internalExpandedKeys, setInternalExpandedKeys] = createSignal(getInitialExpandedKeys(getOptions().defaultExpandedKeys));
-	const expandedKeys = createMemo(() => {
+	const [internalExpandedKeys, setInternalExpandedKeys] = createInternalSignal(getInitialExpandedKeys(getOptions().defaultExpandedKeys));
+	const expandedKeys = () => {
 		const opts = getOptions();
 		if (opts.expandedKeys !== void 0) return new Set(opts.expandedKeys);
 		return internalExpandedKeys();
-	});
+	};
 	const collection = createMemo(() => {
 		return getOptions().collectionFactory(expandedKeys());
 	});
-	const [isFocused, setIsFocused] = createSignal(false);
-	const [focusedKey, setFocusedKeyInternal] = createSignal(null);
-	const [childFocusStrategy, setChildFocusStrategy] = createSignal(null);
-	const [isKeyboardNavigationDisabled, setKeyboardNavigationDisabled] = createSignal(false);
-	const [internalSelectedKeys, setInternalSelectedKeys] = createSignal(getInitialSelection(getOptions().defaultSelectedKeys));
-	const [anchorKey, setAnchorKey] = createSignal(null);
-	const selectedKeys = createMemo(() => {
+	const [isFocused, setIsFocused] = createInternalSignal(false);
+	const [focusedKey, setFocusedKeyInternal] = createInternalSignal(null);
+	const [childFocusStrategy, setChildFocusStrategy] = createInternalSignal(null);
+	const [isKeyboardNavigationDisabled, setKeyboardNavigationDisabled] = createInternalSignal(false);
+	const [internalSelectedKeys, setInternalSelectedKeys] = createInternalSignal(getInitialSelection(getOptions().defaultSelectedKeys));
+	const [anchorKey, setAnchorKey] = createInternalSignal(null);
+	const selectedKeys = () => {
 		const opts = getOptions();
 		if (opts.selectedKeys !== void 0) return normalizeSelection(opts.selectedKeys);
 		return internalSelectedKeys();
-	});
+	};
 	const selectionMode = createMemo(() => getOptions().selectionMode ?? "none");
 	const selectionBehaviorProp = () => getOptions().selectionBehavior ?? "toggle";
-	const [selectionBehaviorState, setSelectionBehaviorState] = createSignal(selectionBehaviorProp());
+	const [selectionBehaviorState, setSelectionBehaviorState] = createInternalSignal(selectionBehaviorProp());
 	const selectionBehavior = createMemo(() => selectionBehaviorState());
 	const disallowEmptySelection = createMemo(() => getOptions().disallowEmptySelection ?? false);
 	const disabledBehavior = createMemo(() => getOptions().disabledBehavior ?? "all");
-	createEffect(on(selectionBehaviorProp, (behavior) => setSelectionBehaviorState(behavior)));
-	createEffect(() => {
-		const keys = selectedKeys();
-		if (selectionBehaviorProp() === "replace" && selectionBehaviorState() === "toggle" && keys !== "all" && keys.size === 0) setSelectionBehaviorState("replace");
+	createEffect(selectionBehaviorProp, (behavior) => {
+		setSelectionBehaviorState(behavior);
+	});
+	createEffect(() => ({
+		prop: selectionBehaviorProp(),
+		state: selectionBehaviorState(),
+		keys: selectedKeys()
+	}), ({ prop, state, keys }) => {
+		if (prop === "replace" && state === "toggle" && keys !== "all" && keys.size === 0) setSelectionBehaviorState("replace");
 	});
 	const setFocusedKey = (key, strategy = "first") => {
 		setFocusedKeyInternal(key);
 		setChildFocusStrategy(strategy);
 	};
-	let cachedCollection = null;
-	createEffect(on(collection, (coll) => {
-		const currentFocusedKey = focusedKey();
+	let cachedCollection = collection();
+	createEffect(() => ({
+		coll: collection(),
+		currentFocusedKey: focusedKey(),
+		disabled: disabledKeys()
+	}), ({ coll, currentFocusedKey, disabled }) => {
 		if (currentFocusedKey != null && cachedCollection) {
 			const visibleKeys = [...coll.getKeys()];
 			if (!visibleKeys.includes(currentFocusedKey)) {
@@ -6792,13 +8077,13 @@ function createTreeState(options) {
 					const cachedNode = cachedCollection.getItem(currentFocusedKey);
 					if (cachedNode?.rowIndex !== void 0) {
 						const newNode = rows[Math.min(cachedNode.rowIndex, rows.length - 1)];
-						if (newNode && !disabledKeys().has(newNode.key)) {
+						if (newNode && !disabled.has(newNode.key)) {
 							setFocusedKeyInternal(newNode.key);
 							cachedCollection = coll;
 							return;
 						}
 					}
-					for (const row of rows) if (!disabledKeys().has(row.key)) {
+					for (const row of rows) if (!disabled.has(row.key)) {
 						setFocusedKeyInternal(row.key);
 						break;
 					}
@@ -6806,7 +8091,7 @@ function createTreeState(options) {
 			}
 		}
 		cachedCollection = coll;
-	}));
+	});
 	const isSelected = (key) => {
 		const keys = selectedKeys();
 		if (keys === "all") return true;
@@ -6836,7 +8121,7 @@ function createTreeState(options) {
 		const current = selectedKeys();
 		if (selectionMode() === "single") {
 			if (isSelected(key) && !disallowEmptySelection()) updateSelection(/* @__PURE__ */ new Set());
-			else updateSelection(new Set([key]));
+			else updateSelection(/* @__PURE__ */ new Set([key]));
 			return;
 		}
 		if (current === "all") return;
@@ -6850,7 +8135,7 @@ function createTreeState(options) {
 	const replaceSelection = (key) => {
 		if (isDisabled(key)) return;
 		if (selectionMode() === "none") return;
-		updateSelection(new Set([key]));
+		updateSelection(/* @__PURE__ */ new Set([key]));
 		setAnchorKey(key);
 	};
 	const setSelectedKeys = (keys) => {
@@ -6862,7 +8147,7 @@ function createTreeState(options) {
 			replaceSelection(toKey);
 			return;
 		}
-		const anchor = anchorKey();
+		const anchor = anchorKey() ?? focusedKey();
 		if (!anchor) {
 			replaceSelection(toKey);
 			return;
@@ -8544,6 +9829,14 @@ function clamp(value, min, max) {
 	return Math.min(Math.max(value, min), max);
 }
 /**
+* Normalizes a hue value to [0, 360).
+* Preserves 360 so linear hue sliders can reach the end of their track.
+*/
+function normalizeHue(hue) {
+	if (hue === 360) return hue;
+	return (hue % 360 + 360) % 360;
+}
+/**
 * Round to fixed decimal places.
 */
 function toFixed(value, decimals) {
@@ -8571,9 +9864,7 @@ function rgbToHsl(r, g, b) {
 			case g:
 				h = ((b - r) / d + 2) / 6;
 				break;
-			case b:
-				h = ((r - g) / d + 4) / 6;
-				break;
+			case b: h = ((r - g) / d + 4) / 6;
 		}
 	}
 	return {
@@ -8622,9 +9913,7 @@ function rgbToHsb(r, g, b) {
 		case g:
 			h = ((b - r) / d + 2) / 6;
 			break;
-		case b:
-			h = ((r - g) / d + 4) / 6;
-			break;
+		case b: h = ((r - g) / d + 4) / 6;
 	}
 	return {
 		h: toFixed(h * 360, 2),
@@ -8656,8 +9945,10 @@ function getOklchHueName(l, c, h, locale) {
 		let [hue, hueName] = OKLCH_HUES[i];
 		const [nextHue, nextHueName] = OKLCH_HUES[i + 1] || [360, "pink"];
 		if (h >= hue && h < nextHue) {
-			if (hueName === "orange") if (l < ORANGE_LIGHTNESS_THRESHOLD) hueName = "brown";
-			else l = l - ORANGE_LIGHTNESS_THRESHOLD + MAX_DARK_LIGHTNESS;
+			if (hueName === "orange") {
+				if (l < ORANGE_LIGHTNESS_THRESHOLD) hueName = "brown";
+				else l = l - ORANGE_LIGHTNESS_THRESHOLD + MAX_DARK_LIGHTNESS;
+			}
 			if (h > hue + (nextHue - hue) / 2 && hueName !== nextHueName) hueName = `${hueName} ${nextHueName}`;
 			else if (hueName === "yellow" && l < YELLOW_GREEN_LIGHTNESS_THRESHOLD) hueName = "yellow green";
 			return [getColorStringForLocale(hueName, locale).toLocaleLowerCase(locale), l];
@@ -8920,7 +10211,7 @@ var HSLColorImpl = class HSLColorImpl {
 	lightness;
 	alpha;
 	constructor(hue, saturation, lightness, alpha = 1) {
-		this.hue = clamp(hue % 360, 0, 360);
+		this.hue = clamp(normalizeHue(hue), 0, 360);
 		this.saturation = clamp(saturation, 0, 100);
 		this.lightness = clamp(lightness, 0, 100);
 		this.alpha = clamp(toFixed(alpha, 2), 0, 1);
@@ -8938,9 +10229,11 @@ var HSLColorImpl = class HSLColorImpl {
 			}
 			case "hsb":
 			case "hsba": {
-				const { r, g, b } = hslToRgb(this.hue, this.saturation, this.lightness);
-				const hsb = rgbToHsb(r, g, b);
-				return new HSBColorImpl(hsb.h, hsb.s, hsb.b, this.alpha);
+				const saturation = this.saturation / 100;
+				const lightness = this.lightness / 100;
+				const brightness = lightness + saturation * Math.min(lightness, 1 - lightness);
+				const hsbSaturation = brightness === 0 ? 0 : 2 * (1 - lightness / brightness);
+				return new HSBColorImpl(toFixed(this.hue, 2), toFixed(hsbSaturation * 100, 2), toFixed(brightness * 100, 2), this.alpha);
 			}
 			default: throw new Error(`Unsupported format: ${format}`);
 		}
@@ -9007,8 +10300,7 @@ var HSLColorImpl = class HSLColorImpl {
 		if (channel === "hue") return {
 			style: "unit",
 			unit: "degree",
-			unitDisplay: "narrow",
-			maximumFractionDigits: 0
+			unitDisplay: "narrow"
 		};
 		return {
 			style: "percent",
@@ -9060,7 +10352,7 @@ var HSBColorImpl = class HSBColorImpl {
 	brightness;
 	alpha;
 	constructor(hue, saturation, brightness, alpha = 1) {
-		this.hue = clamp(hue % 360, 0, 360);
+		this.hue = clamp(normalizeHue(hue), 0, 360);
 		this.saturation = clamp(saturation, 0, 100);
 		this.brightness = clamp(brightness, 0, 100);
 		this.alpha = clamp(toFixed(alpha, 2), 0, 1);
@@ -9078,9 +10370,11 @@ var HSBColorImpl = class HSBColorImpl {
 			}
 			case "hsl":
 			case "hsla": {
-				const { r, g, b } = hsbToRgb(this.hue, this.saturation, this.brightness);
-				const hsl = rgbToHsl(r, g, b);
-				return new HSLColorImpl(hsl.h, hsl.s, hsl.l, this.alpha);
+				const saturation = this.saturation / 100;
+				const brightness = this.brightness / 100;
+				const lightness = brightness * (1 - saturation / 2);
+				const hslSaturation = lightness === 0 || lightness === 1 ? 0 : (brightness - lightness) / Math.min(lightness, 1 - lightness);
+				return new HSLColorImpl(toFixed(this.hue, 2), toFixed(hslSaturation * 100, 2), toFixed(lightness * 100, 2), this.alpha);
 			}
 			default: throw new Error(`Unsupported format: ${format}`);
 		}
@@ -9147,8 +10441,7 @@ var HSBColorImpl = class HSBColorImpl {
 		if (channel === "hue") return {
 			style: "unit",
 			unit: "degree",
-			unitDisplay: "narrow",
-			maximumFractionDigits: 0
+			unitDisplay: "narrow"
 		};
 		return {
 			style: "percent",
@@ -9207,10 +10500,10 @@ function parseColor(value) {
 	}
 	const rgbMatch = trimmed.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)$/);
 	if (rgbMatch) return new RGBColorImpl(parseInt(rgbMatch[1], 10), parseInt(rgbMatch[2], 10), parseInt(rgbMatch[3], 10), rgbMatch[4] !== void 0 ? parseFloat(rgbMatch[4]) : 1);
-	const hslMatch = trimmed.match(/^hsla?\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(?:,\s*([\d.]+))?\s*\)$/);
-	if (hslMatch) return new HSLColorImpl(parseInt(hslMatch[1], 10), parseInt(hslMatch[2], 10), parseInt(hslMatch[3], 10), hslMatch[4] !== void 0 ? parseFloat(hslMatch[4]) : 1);
-	const hsbMatch = trimmed.match(/^hsba?\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*(?:,\s*([\d.]+))?\s*\)$/);
-	if (hsbMatch) return new HSBColorImpl(parseInt(hsbMatch[1], 10), parseInt(hsbMatch[2], 10), parseInt(hsbMatch[3], 10), hsbMatch[4] !== void 0 ? parseFloat(hsbMatch[4]) : 1);
+	const hslMatch = trimmed.match(/^hsla?\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*(?:,\s*([-+]?\d+(?:\.\d+)?))?\s*\)$/);
+	if (hslMatch) return new HSLColorImpl(parseFloat(hslMatch[1]), parseFloat(hslMatch[2]), parseFloat(hslMatch[3]), hslMatch[4] !== void 0 ? parseFloat(hslMatch[4]) : 1);
+	const hsbMatch = trimmed.match(/^hsba?\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*(?:,\s*([-+]?\d+(?:\.\d+)?))?\s*\)$/);
+	if (hsbMatch) return new HSBColorImpl(parseFloat(hsbMatch[1]), parseFloat(hsbMatch[2]), parseFloat(hsbMatch[3]), hsbMatch[4] !== void 0 ? parseFloat(hsbMatch[4]) : 1);
 	throw new Error(`Invalid color format: ${value}`);
 }
 /**
@@ -9254,8 +10547,8 @@ function createColorSliderState(options) {
 		const colorSpace = getOptions().colorSpace;
 		return colorSpace ? color.toFormat(colorSpace) : color;
 	};
-	const [internalValue, setInternalValue] = createSignal(null);
-	const [isDragging, setIsDragging] = createSignal(false);
+	const [internalValue, setInternalValue] = createInternalSignal(null);
+	const [isDragging, setIsDragging] = createInternalSignal(false);
 	const initValue = () => {
 		const opts = getOptions();
 		if (opts.defaultValue) return normalizeValue(opts.defaultValue);
@@ -9280,9 +10573,11 @@ function createColorSliderState(options) {
 	const pageSize = createMemo(() => channelRange().pageSize);
 	const minValue = createMemo(() => channelRange().minValue);
 	const maxValue = createMemo(() => channelRange().maxValue);
+	let lastValue = internalValue();
 	const updateValue = (newColor) => {
 		const opts = getOptions();
 		const nextColor = opts.colorSpace ? newColor.toFormat(opts.colorSpace) : newColor;
+		lastValue = nextColor;
 		if (opts.value !== void 0) {
 			opts.onChange?.(nextColor);
 			return;
@@ -9290,8 +10585,9 @@ function createColorSliderState(options) {
 		setInternalValue(nextColor);
 		opts.onChange?.(nextColor);
 	};
+	const liveColor = () => lastValue ?? internalValue() ?? value();
 	const getThumbValue = () => {
-		return value().getChannelValue(channel());
+		return liveColor().getChannelValue(channel());
 	};
 	const getThumbMinValue = () => minValue();
 	const getThumbMaxValue = () => maxValue();
@@ -9308,11 +10604,13 @@ function createColorSliderState(options) {
 		const clamped = Math.max(min, Math.min(max, newValue));
 		const precision = `${stepValue}`.split(".")[1]?.length ?? 0;
 		const rounded = Number((Math.round((clamped - min) / stepValue) * stepValue + min).toFixed(precision));
-		updateValue(value().withChannelValue(channel(), rounded));
+		const newColor = liveColor().withChannelValue(channel(), rounded);
+		updateValue(newColor);
 	};
 	const setThumbPercent = (percent) => {
 		const min = minValue();
-		setThumbValue(min + (maxValue() - min) * percent);
+		const val = min + (maxValue() - min) * percent;
+		setThumbValue(val);
 	};
 	const incrementThumb = (stepSize) => {
 		const s = stepSize ?? step();
@@ -9323,9 +10621,13 @@ function createColorSliderState(options) {
 		setThumbValue(getThumbValue() - s);
 	};
 	const setDraggingState = (dragging) => {
-		const wasDragging = isDragging();
+		const wasDragging = readNow(isDragging);
 		setIsDragging(dragging);
-		if (wasDragging && !dragging) getOptions().onChangeEnd?.(value());
+		if (wasDragging && !dragging) {
+			const opts = getOptions();
+			const current = lastValue ?? (opts.value !== void 0 ? normalizeValue(opts.value) : null) ?? internalValue() ?? value();
+			opts.onChangeEnd?.(current);
+		}
 	};
 	const getDisplayColor = () => {
 		const v = value();
@@ -9395,8 +10697,8 @@ function createColorAreaState(options) {
 		const colorSpace = getOptions().colorSpace;
 		return colorSpace ? color.toFormat(colorSpace) : color;
 	};
-	const [internalValue, setInternalValue] = createSignal(null);
-	const [isDragging, setIsDragging] = createSignal(false);
+	const [internalValue, setInternalValue] = createInternalSignal(null);
+	const [isDragging, setIsDragging] = createInternalSignal(false);
 	const initValue = () => {
 		const opts = getOptions();
 		if (opts.defaultValue) return normalizeValue(opts.defaultValue);
@@ -9429,9 +10731,11 @@ function createColorAreaState(options) {
 	const yChannelStep = createMemo(() => yRange().step);
 	const xChannelPageStep = createMemo(() => xRange().pageSize);
 	const yChannelPageStep = createMemo(() => yRange().pageSize);
+	let lastValue = internalValue();
 	const updateValue = (newColor) => {
 		const opts = getOptions();
 		const nextColor = opts.colorSpace ? newColor.toFormat(opts.colorSpace) : newColor;
+		lastValue = nextColor;
 		if (opts.value !== void 0) {
 			opts.onChange?.(nextColor);
 			return;
@@ -9445,13 +10749,15 @@ function createColorAreaState(options) {
 		const range = xRange();
 		const clamped = Math.max(range.minValue, Math.min(range.maxValue, newValue));
 		const rounded = Math.round(clamped / range.step) * range.step;
-		updateValue(value().withChannelValue(xChannel(), rounded));
+		const newColor = value().withChannelValue(xChannel(), rounded);
+		updateValue(newColor);
 	};
 	const setYValue = (newValue) => {
 		const range = yRange();
 		const clamped = Math.max(range.minValue, Math.min(range.maxValue, newValue));
 		const rounded = Math.round(clamped / range.step) * range.step;
-		updateValue(value().withChannelValue(yChannel(), rounded));
+		const newColor = value().withChannelValue(yChannel(), rounded);
+		updateValue(newColor);
 	};
 	const setColorFromPoint = (x, y) => {
 		const xR = xRange();
@@ -9462,7 +10768,8 @@ function createColorAreaState(options) {
 		const yClamped = Math.max(yR.minValue, Math.min(yR.maxValue, yVal));
 		const xRounded = Math.round(xClamped / xR.step) * xR.step;
 		const yRounded = Math.round(yClamped / yR.step) * yR.step;
-		updateValue(value().withChannelValue(xChannel(), xRounded).withChannelValue(yChannel(), yRounded));
+		const newColor = value().withChannelValue(xChannel(), xRounded).withChannelValue(yChannel(), yRounded);
+		updateValue(newColor);
 	};
 	const getThumbPosition = () => {
 		const xR = xRange();
@@ -9493,7 +10800,11 @@ function createColorAreaState(options) {
 	const setDraggingState = (dragging) => {
 		const wasDragging = isDragging();
 		setIsDragging(dragging);
-		if (wasDragging && !dragging) getOptions().onChangeEnd?.(value());
+		if (wasDragging && !dragging) {
+			const opts = getOptions();
+			const current = lastValue ?? (opts.value !== void 0 ? normalizeValue(opts.value) : null) ?? internalValue() ?? value();
+			opts.onChangeEnd?.(current);
+		}
 	};
 	const getDisplayColor = () => {
 		return value().withChannelValue("alpha", 1);
@@ -9560,8 +10871,8 @@ function createColorWheelState(options) {
 		return value.toFormat(value.getColorSpace() === "hsb" ? "hsb" : "hsl");
 	};
 	const initialValue = normalizeWheelValue(getOptions().defaultValue ?? defaultColor);
-	const [internalValue, setInternalValue] = createSignal(initialValue);
-	const [isDragging, setIsDragging] = createSignal(false);
+	const [internalValue, setInternalValue] = createInternalSignal(initialValue);
+	const [isDragging, setIsDragging] = createInternalSignal(false);
 	let valueRef = initialValue;
 	const value = createMemo(() => {
 		const opts = getOptions();
@@ -9612,9 +10923,11 @@ function createColorWheelState(options) {
 	const setHue = (newValue) => {
 		const currentHue = getHue();
 		const range = hueRange();
-		const rounded = roundToStep(mod(newValue > range.maxValue ? range.minValue : newValue, range.maxValue), range.step);
+		const hue = newValue > range.maxValue ? range.minValue : newValue;
+		const rounded = roundToStep(mod(hue, range.maxValue), range.step);
 		if (rounded === currentHue) return;
-		updateValue(value().withChannelValue("hue", rounded));
+		const newColor = value().withChannelValue("hue", rounded);
+		updateValue(newColor);
 	};
 	const setHueFromAngle = (angle) => {
 		setHue(mod(360 - radToDeg(angle), 360));
@@ -9648,7 +10961,7 @@ function createColorWheelState(options) {
 		setHue(roundToStep(mod(getHue() - s, range.maxValue), s));
 	};
 	const setDraggingState = (dragging) => {
-		const wasDragging = isDragging();
+		const wasDragging = readNow(isDragging);
 		setIsDragging(dragging);
 		if (wasDragging && !dragging) getOptions().onChangeEnd?.(valueRef);
 	};
@@ -9728,7 +11041,10 @@ function formatColorValue(color, channel, colorSpace, format, locale) {
 	if (!color) return "";
 	const displayColor = getDisplayColor(color, colorSpace);
 	if (channel) return displayColor.formatChannelValue(channel, locale);
-	return displayColor.toString(format ?? "hex");
+	const formatted = displayColor.toString(format ?? "hex");
+	const resolvedFormat = format ?? "hex";
+	if (resolvedFormat === "hex" || resolvedFormat === "hexa") return formatted.toUpperCase();
+	return formatted;
 }
 function normalizeHexInput(value) {
 	return value.startsWith("#") ? value : `#${value}`;
@@ -9759,9 +11075,9 @@ function createColorFieldState(options) {
 	const getOptions = () => options();
 	const initialOptions = getOptions();
 	const initialValue = getDefaultValue(initialOptions);
-	const [internalValue, setInternalValue] = createSignal(initialValue);
-	const [inputValue, setInputValueInternal] = createSignal(formatColorValue(initialValue, initialOptions.channel, initialOptions.colorSpace, initialOptions.colorFormat, initialOptions.locale ?? "en-US"));
-	const [invalidInput, setInvalidInput] = createSignal(false);
+	const [internalValue, setInternalValue] = createInternalSignal(initialValue);
+	const [inputValue, setInputValueInternal] = createInternalSignal(formatColorValue(initialValue, initialOptions.channel, initialOptions.colorSpace, initialOptions.colorFormat, initialOptions.locale ?? "en-US"));
+	const [invalidInput, setInvalidInput] = createInternalSignal(false);
 	const channel = createMemo(() => getOptions().channel);
 	const colorSpace = createMemo(() => getOptions().colorSpace);
 	const locale = createMemo(() => getOptions().locale ?? "en-US");
@@ -9776,8 +11092,8 @@ function createColorFieldState(options) {
 	const isRequired = createMemo(() => getOptions().isRequired ?? false);
 	const isInvalid = createMemo(() => (getOptions().isInvalid ?? false) || invalidInput());
 	const formatCurrentValue = (color = value()) => formatColorValue(color, channel(), colorSpace(), getOptions().colorFormat, locale());
-	createEffect(() => {
-		setInputValueInternal(formatCurrentValue());
+	createEffect(() => formatCurrentValue(), (formatted) => {
+		setInputValueInternal(formatted);
 		setInvalidInput(false);
 	});
 	const updateValue = (newColor) => {
@@ -9795,7 +11111,7 @@ function createColorFieldState(options) {
 		updateValue(newColor);
 	};
 	const commit = () => {
-		const text = inputValue().trim();
+		const text = readNow(inputValue).trim();
 		const opts = getOptions();
 		const chan = channel();
 		if (!text) {
@@ -9866,7 +11182,7 @@ function createColorFieldState(options) {
 		updateChannel("min");
 	};
 	const validate = (candidate) => {
-		const text = (candidate ?? inputValue()).trim();
+		const text = (candidate ?? readNow(inputValue)).trim();
 		const chan = channel();
 		if (!text) return true;
 		if (chan) return parseChannelValue(text, colorValue(), chan) != null;
@@ -9938,6 +11254,8 @@ function createColorFieldState(options) {
 * Drag state management for solid-stately.
 *
 * Provides reactive state for drag operations.
+*
+* Ported from packages/react-aria/src/dnd/useDrag.ts.
 */
 /**
 * Creates drag state for managing drag operations.
@@ -9947,7 +11265,7 @@ function createColorFieldState(options) {
 */
 function createDragState(props) {
 	const getProps = createMemo(() => props());
-	const [isDragging, setIsDragging] = createSignal(false);
+	const [isDragging, setIsDragging] = createInternalSignal(false);
 	const startDrag = (x, y) => {
 		const p = getProps();
 		if (p.isDisabled) return;
@@ -9960,7 +11278,7 @@ function createDragState(props) {
 	};
 	const moveDrag = (x, y) => {
 		const p = getProps();
-		if (!isDragging() || p.isDisabled) return;
+		if (!readNow(isDragging) || p.isDisabled) return;
 		if (typeof p.onDragMove === "function") p.onDragMove({
 			type: "dragmove",
 			x,
@@ -9969,7 +11287,7 @@ function createDragState(props) {
 	};
 	const endDrag = (x, y, dropOperation) => {
 		const p = getProps();
-		if (!isDragging()) return;
+		if (!readNow(isDragging)) return;
 		setIsDragging(false);
 		if (typeof p.onDragEnd === "function") p.onDragEnd({
 			type: "dragend",
@@ -10020,6 +11338,8 @@ function createDragState(props) {
 * Drop state management for solid-stately.
 *
 * Provides reactive state for drop target operations.
+*
+* Ported from packages/react-aria/src/dnd/useDrop.ts.
 */
 /**
 * Creates drop state for managing drop target operations.
@@ -10029,7 +11349,7 @@ function createDragState(props) {
 */
 function createDropState(props) {
 	const getProps = createMemo(() => props());
-	const [isDropTarget, setIsDropTarget] = createSignal(false);
+	const [isDropTarget, setIsDropTarget] = createInternalSignal(false);
 	const enterTarget = (x, y) => {
 		const p = getProps();
 		if (p.isDisabled) return;
@@ -10042,7 +11362,7 @@ function createDropState(props) {
 	};
 	const moveInTarget = (x, y) => {
 		const p = getProps();
-		if (!isDropTarget() || p.isDisabled) return;
+		if (!readNow(isDropTarget) || p.isDisabled) return;
 		if (typeof p.onDropMove === "function") p.onDropMove({
 			type: "dropmove",
 			x,
@@ -10114,7 +11434,51 @@ function createDropState(props) {
 * Draggable collection state management for solid-stately.
 *
 * Provides reactive state for dragging items from a collection.
+*
+* Ported from packages/react-stately/src/dnd/useDraggableCollectionState.ts.
+*/
+function selectedKeySet(selectedKeys, collection) {
+	if (selectedKeys === "all") {
+		if (!collection?.getKeys) return "all";
+		return new Set(collection.getKeys());
+	}
+	return new Set(selectedKeys ?? []);
+}
+/**
+* RAC `useDraggableCollectionState.ts` `getKeys`. The clicked item always
+* drags. If it is selected, every selected item that is not a child of another
+* selected item is included.
 */
+function getKeysForDrag(key, options) {
+	const selected = selectedKeySet(options.selectedKeys, options.collection);
+	if (!(options.isSelected?.(key) ?? (selected === "all" ? true : selected.has(key)))) return /* @__PURE__ */ new Set([key]);
+	const keys = /* @__PURE__ */ new Set();
+	const selectedKeys = selected === "all" ? options.collection?.getKeys?.() : selected;
+	if (!selectedKeys) {
+		keys.add(key);
+		return keys;
+	}
+	for (const currentKey of selectedKeys) {
+		const node = options.collection?.getItem(currentKey);
+		if (!node) {
+			keys.add(currentKey);
+			continue;
+		}
+		let isChild = false;
+		let parentKey = node.parentKey;
+		while (parentKey != null) {
+			if (options.isSelected?.(parentKey) ?? (selected === "all" ? true : selected.has(parentKey))) {
+				isChild = true;
+				break;
+			}
+			const parentNode = options.collection?.getItem(parentKey);
+			parentKey = parentNode ? parentNode.parentKey : null;
+		}
+		if (!isChild) keys.add(currentKey);
+	}
+	if (keys.size === 0) keys.add(key);
+	return keys;
+}
 /**
 * Creates state for dragging items from a collection.
 *
@@ -10123,8 +11487,8 @@ function createDropState(props) {
 */
 function createDraggableCollectionState(props) {
 	const getProps = createMemo(() => props());
-	const [isDragging, setIsDragging] = createSignal(false);
-	const [draggingKeys, setDraggingKeys] = createSignal(/* @__PURE__ */ new Set());
+	const [isDragging, setIsDragging] = createInternalSignal(false);
+	const [draggingKeys, setDraggingKeys] = createInternalSignal(/* @__PURE__ */ new Set());
 	const startDrag = (keys, x, y) => {
 		const p = getProps();
 		if (p.isDisabled) return;
@@ -10139,17 +11503,17 @@ function createDraggableCollectionState(props) {
 	};
 	const moveDrag = (x, y) => {
 		const p = getProps();
-		if (!isDragging() || p.isDisabled) return;
+		if (!readNow(isDragging) || p.isDisabled) return;
 		if (typeof p.onDragMove === "function") p.onDragMove({
 			type: "dragmove",
 			x,
 			y,
-			keys: draggingKeys()
+			keys: readNow(draggingKeys)
 		});
 	};
 	const endDrag = (x, y, dropOperation, isInternal) => {
 		const p = getProps();
-		const keys = draggingKeys();
+		const keys = readNow(draggingKeys);
 		setIsDragging(false);
 		setDraggingKeys(/* @__PURE__ */ new Set());
 		if (typeof p.onDragEnd === "function") p.onDragEnd({
@@ -10194,7 +11558,21 @@ function createDraggableCollectionState(props) {
 		endDrag,
 		cancelDrag,
 		getItems,
-		getAllowedDropOperations
+		getAllowedDropOperations,
+		getKeysForDrag: (key) => {
+			const p = getProps();
+			return getKeysForDrag(key, {
+				collection: p.collection,
+				selectedKeys: p.selectedKeys,
+				isSelected: p.isSelected
+			});
+		},
+		isSelected: (key) => {
+			const p = getProps();
+			if (p.isSelected) return p.isSelected(key);
+			const selected = selectedKeySet(p.selectedKeys, p.collection);
+			return selected === "all" ? true : selected.has(key);
+		}
 	};
 }
 //#endregion
@@ -10203,6 +11581,8 @@ function createDraggableCollectionState(props) {
 * Droppable collection state management for solid-stately.
 *
 * Provides reactive state for accepting drops onto a collection.
+*
+* Ported from packages/react-stately/src/dnd/useDroppableCollectionState.ts.
 */
 /**
 * Symbol for directory drag type.
@@ -10216,8 +11596,8 @@ const DIRECTORY_DRAG_TYPE = Symbol("directory");
 */
 function createDroppableCollectionState(props) {
 	const getProps = createMemo(() => props());
-	const [isDropTarget, setIsDropTarget] = createSignal(false);
-	const [target, setTarget] = createSignal(null);
+	const [isDropTarget, setIsDropTarget] = createInternalSignal(false);
+	const [target, setTarget] = createInternalSignal(null);
 	const isAccepted = (types) => {
 		const acceptedTypes = getProps().acceptedDragTypes ?? "all";
 		if (acceptedTypes === "all") return true;
@@ -10369,6 +11749,19 @@ function createDroppableCollectionState(props) {
 		if (typeof p.shouldAcceptItemDrop === "function") return p.shouldAcceptItemDrop(dropTarget, types);
 		return true;
 	};
+	const isDropTargetFor = (dropTarget) => {
+		const current = target();
+		if (!current || !dropTarget) return false;
+		if (targetsEqual(current, dropTarget)) return true;
+		if (dropTarget.type !== "item" || current.type !== "item" || dropTarget.key === current.key || dropTarget.dropPosition === current.dropPosition || dropTarget.dropPosition === "on" || current.dropPosition === "on") return false;
+		const collection = getProps().collection;
+		if (!collection) return false;
+		return dropTargetsEqual(getOppositeTarget(collection, dropTarget), current) || dropTargetsEqual(dropTarget, getOppositeTarget(collection, current));
+	};
+	const assignTarget = (newTarget) => {
+		if (isDropTargetFor(newTarget)) return;
+		setTarget(newTarget);
+	};
 	return {
 		get isDropTarget() {
 			return isDropTarget();
@@ -10379,7 +11772,7 @@ function createDroppableCollectionState(props) {
 		get isDisabled() {
 			return getProps().isDisabled ?? false;
 		},
-		setTarget,
+		setTarget: assignTarget,
 		isAccepted,
 		enterTarget,
 		moveToTarget,
@@ -10387,18 +11780,50 @@ function createDroppableCollectionState(props) {
 		activateTarget,
 		drop,
 		getDropOperation,
-		shouldAcceptItemDrop
+		shouldAcceptItemDrop,
+		isDropTargetFor
 	};
 }
 /**
 * Check if two drop targets are equal.
 */
 function targetsEqual(a, b) {
+	return dropTargetsEqual(a, b);
+}
+function dropTargetsEqual(a, b) {
+	if (!a || !b) return false;
 	if (a.type !== b.type) return false;
 	if (a.type === "root" && b.type === "root") return true;
 	if (a.type === "item" && b.type === "item") return a.key === b.key && a.dropPosition === b.dropPosition;
 	return false;
 }
+function nextItemKey(collection, fromKey, direction) {
+	let key = direction === "before" ? collection.getKeyBefore(fromKey) : collection.getKeyAfter(fromKey);
+	while (key != null) {
+		if (collection.getItem(key)?.type === "item") return key;
+		key = direction === "before" ? collection.getKeyBefore(key) : collection.getKeyAfter(key);
+	}
+	return null;
+}
+function getOppositeTarget(collection, target) {
+	if (target.dropPosition === "before") {
+		const prevKey = nextItemKey(collection, target.key, "before");
+		return prevKey != null ? {
+			type: "item",
+			key: prevKey,
+			dropPosition: "after"
+		} : null;
+	}
+	if (target.dropPosition === "after") {
+		const nextKey = nextItemKey(collection, target.key, "after");
+		return nextKey != null ? {
+			type: "item",
+			key: nextKey,
+			dropPosition: "before"
+		} : null;
+	}
+	return null;
+}
 //#endregion
 //#region src/data/createListData.ts
 /**
@@ -10406,6 +11831,8 @@ function targetsEqual(a, b) {
 *
 * Manages state for an immutable list data structure, and provides
 * convenience methods to update the data over time.
+*
+* Ported from packages/react-stately/src/data/useListData.ts.
 */
 /**
 * Manages state for an immutable list data structure, and provides
@@ -10417,7 +11844,7 @@ function createListData(options) {
 		return candidate.id ?? candidate.key ?? String(item);
 	};
 	const { initialItems = [], initialSelectedKeys, getKey = defaultGetKey, filter, initialFilterText = "" } = options;
-	const [state, setState] = createSignal({
+	const [state, setState] = createInternalSignal({
 		items: initialItems,
 		selectedKeys: initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys || []),
 		filterText: initialFilterText
@@ -10451,7 +11878,7 @@ function createListData(options) {
 				};
 				return {
 					...s,
-					selectedKeys: new Set([...s.selectedKeys, ...selectedKeys])
+					selectedKeys: /* @__PURE__ */ new Set([...s.selectedKeys, ...selectedKeys])
 				};
 			});
 		},
@@ -10491,8 +11918,10 @@ function createListData(options) {
 		insertAfter(key, ...values) {
 			setState((s) => {
 				let index = s.items.findIndex((item) => getKey(item) === key);
-				if (index === -1) if (s.items.length === 0) index = 0;
-				else return s;
+				if (index === -1) {
+					if (s.items.length === 0) index = 0;
+					else return s;
+				}
 				return insertItems(s, index + 1, ...values);
 			});
 		},
@@ -10624,6 +12053,8 @@ function moveItems$1(state, indices, toIndex) {
 *
 * Manages state for an immutable tree data structure, and provides
 * convenience methods to update the data over time.
+*
+* Ported from packages/react-stately/src/data/useTreeData.ts.
 */
 /**
 * Manages state for an immutable tree data structure, and provides
@@ -10638,8 +12069,8 @@ function createTreeData(options) {
 		return item.children ?? [];
 	};
 	const { initialItems = [], initialSelectedKeys, getKey = defaultGetKey, getChildren = defaultGetChildren } = options;
-	const [treeState, setTreeState] = createSignal(buildTree(initialItems, /* @__PURE__ */ new Map(), null, getKey, getChildren));
-	const [selectedKeys, setSelectedKeys] = createSignal(initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys || []));
+	const [treeState, setTreeState] = createInternalSignal(buildTree(initialItems, /* @__PURE__ */ new Map(), null, getKey, getChildren));
+	const [selectedKeys, setSelectedKeys] = createInternalSignal(initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys || []));
 	function updateTree(items, key, update, originalMap) {
 		let node = key != null ? originalMap.get(key) : null;
 		if (key != null && !node) return {
@@ -11040,6 +12471,10 @@ function moveItems(state, keys, toParent, toIndex, updateTreeFn, addNodeFn) {
 * Manages state for an immutable async loaded list data structure, and provides
 * convenience methods to update the data over time. Manages loading and error
 * states, pagination, and sorting.
+*
+* Ported from:
+* - packages/react-stately/src/data/useAsyncList.ts
+* - packages/react-stately/src/data/useListData.ts
 */
 /**
 * Manages state for an immutable async loaded list data structure, and provides
@@ -11052,7 +12487,7 @@ function createAsyncList(options) {
 		return candidate.id ?? candidate.key ?? String(item);
 	};
 	const { load, sort: sortFn, initialSelectedKeys, initialSortDescriptor, getKey = defaultGetKey, initialFilterText = "" } = options;
-	const [state, setState] = createSignal({
+	const [state, setState] = createInternalSignal({
 		loadingState: "idle",
 		items: [],
 		selectedKeys: initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys || []),
@@ -11089,7 +12524,7 @@ function createAsyncList(options) {
 				const newItems = [...response.items ?? []];
 				const items = type === "loadingMore" ? [...s.items, ...newItems] : newItems;
 				let selectedKeys;
-				if (type === "loadingMore") selectedKeys = s.selectedKeys === "all" || response.selectedKeys === "all" ? "all" : new Set([...s.selectedKeys, ...response.selectedKeys ?? []]);
+				if (type === "loadingMore") selectedKeys = s.selectedKeys === "all" || response.selectedKeys === "all" ? "all" : /* @__PURE__ */ new Set([...s.selectedKeys, ...response.selectedKeys ?? []]);
 				else selectedKeys = response.selectedKeys ? response.selectedKeys === "all" ? "all" : new Set(response.selectedKeys) : s.selectedKeys;
 				return {
 					...s,
@@ -11317,6 +12752,8 @@ function getColorChannels(colorSpace) {
 /**
 * State management for step list components.
 * Tracks selected step, completion status, and selectability.
+*
+* Ported from packages/react-stately/src/steplist/useStepListState.ts.
 */
 /**
 * Creates state for a step list component.
@@ -11332,7 +12769,7 @@ function createStepListState(props) {
 	const disabledKeysSet = createMemo(() => new Set(props.disabledKeys ?? []));
 	const isDisabled = () => props.isDisabled ?? false;
 	const isReadOnly = () => props.isReadOnly ?? false;
-	const [lastCompletedStepInternal, setLastCompletedStepInternal] = createSignal(props.defaultLastCompletedStep ?? null);
+	const [lastCompletedStepInternal, setLastCompletedStepInternal] = createInternalSignal(props.defaultLastCompletedStep ?? null);
 	const lastCompletedStep = () => {
 		if (props.lastCompletedStep !== void 0) return props.lastCompletedStep;
 		return lastCompletedStepInternal();
@@ -11375,7 +12812,7 @@ function createStepListState(props) {
 		for (const item of currentItems) if (!isStepDisabled(item.key)) return item.key;
 		return currentItems.length > 0 ? currentItems[0].key : null;
 	};
-	const [selectedKeyInternal, setSelectedKeyInternal] = createSignal(props.defaultSelectedKey ?? findDefaultSelectedKey());
+	const [selectedKeyInternal, setSelectedKeyInternal] = createInternalSignal(props.defaultSelectedKey ?? findDefaultSelectedKey());
 	const selectedKey = () => {
 		if (props.selectedKey !== void 0) return props.selectedKey;
 		return selectedKeyInternal();
@@ -11394,14 +12831,14 @@ function createStepListState(props) {
 	};
 	createEffect(() => {
 		const selKey = selectedKey();
-		if (selKey === null) return;
+		if (selKey === null) return null;
 		const selIdx = indexMap().get(selKey);
-		if (selIdx === void 0 || selIdx <= 0) return;
+		if (selIdx === void 0 || selIdx <= 0) return null;
 		const completed = lastCompletedStep();
-		if (selIdx > (completed !== null ? indexMap().get(completed) ?? -1 : -1) + 1) {
-			const prevKey = items()[selIdx - 1]?.key;
-			if (prevKey !== void 0) setLastCompletedStep(prevKey);
-		}
+		if (selIdx <= (completed !== null ? indexMap().get(completed) ?? -1 : -1) + 1) return null;
+		return items()[selIdx - 1]?.key;
+	}, (prevKey) => {
+		if (prevKey !== void 0 && prevKey !== null) setLastCompletedStep(prevKey);
 	});
 	return {
 		selectedKey,
@@ -11416,6 +12853,6 @@ function createStepListState(props) {
 	};
 }
 //#endregion
-export { CalendarDateClass, CalendarDateTimeClass, DEFAULT_VALIDATION_RESULT, DIRECTORY_DRAG_TYPE, DateFormatter, FormValidationContext, GregorianCalendar, ListCollection, SelectionManager, TableCollection, TimeClass, Timer, ToastQueue, TreeCollection, VALID_VALIDITY_STATE, ZonedDateTimeClass, access, canUseDOM, createAsyncList, createAutocompleteState, createCalendar, createCalendarState, createCheckboxGroupState, createColorAreaState, createColorFieldState, createColorSliderState, createColorWheelState, createComboBoxState, createDateFieldState, createDateFieldState as useDateFieldState, createDatePickerState, createDatePickerState as useDatePickerState, createDisclosureGroupState, createDisclosureState, createDragState, createDraggableCollectionState, createDropState, createDroppableCollectionState, createFilteredListState, createFormValidationState, createGridState, createHSBColor, createHSLColor, createId, createIsSSR, createListCollection, createListData, createListState, createMenuState, createOverlayTriggerState as createMenuTriggerState, createOverlayTriggerState, createOverlayTriggerState as useMenuTriggerState, createNumberFieldState, createRGBColor, createRadioGroupState, createRangeCalendarState, createRangeCalendarState as useDateRangePickerState, createSearchFieldState, createSelectState, createSelectionState, createSelectionState as useMultipleSelectionState, createSingleSelectListState, createSliderState, createStepListState, createTabListState, createTableCollection, createTableColumnResizeState, createTableState, createTextFieldState, createTimeFieldState, createTimeFieldState as useTimeFieldState, createToastQueue, createToastState, createToggleGroupState, createToggleState, createTooltipTriggerState, createTreeCollection, createTreeData, createTreeGridState, createTreeState, defaultContainsFilter, endOfMonth, endOfWeek, endOfYear, getColorChannels, getDayOfWeek, getItemCount, getLocalTimeZone, getWeeksInMonth, isAccessor, isSameDay, isSameMonth, isSameYear, isServer, isToday, isWeekend, maxDate, mergeValidation, minDate, normalizeColor, now, parseAbsolute, parseAbsoluteToLocal, parseColor, parseDate, parseDateTime, parseTime, parseZonedDateTime, privateValidationStateProp, radioGroupSyncVersion, resetTooltipState, startOfMonth, startOfWeek, startOfYear, toCalendar, toCalendarDate, toCalendarDateTime, toTime, toZoned, today };
+export { CalendarDateClass, CalendarDateTimeClass, DEFAULT_VALIDATION_RESULT, DIRECTORY_DRAG_TYPE, DateFormatter, FormValidationContext, GregorianCalendar, ListCollection, SelectionManager, TableCollection, TimeClass, Timer, ToastQueue, TokenFieldValue, TreeCollection, VALID_VALIDITY_STATE, ZonedDateTimeClass, access, canUseDOM, createAsyncList, createAutocompleteState, createCalendar, createCalendarState, createCheckboxGroupState, createColorAreaState, createColorFieldState, createColorSliderState, createColorWheelState, createComboBoxState, createDateFieldState, createDateFieldState as useDateFieldState, createDatePickerState, createDatePickerState as useDatePickerState, createDisclosureGroupState, createDisclosureState, createDragState, createDraggableCollectionState, createDropState, createDroppableCollectionState, createFilteredListState, createFormValidationState, createGridState, createHSBColor, createHSLColor, createId, createIsSSR, createListCollection, createListData, createListState, createMenuState, createMenuTriggerState, createMenuTriggerState as useMenuTriggerState, createNumberFieldState, createOverlayTriggerState, createRGBColor, createRadioGroupState, createRangeCalendarState, createRangeCalendarState as useDateRangePickerState, createSearchFieldState, createSelectState, createSelectionState, createSelectionState as useMultipleSelectionState, createSingleSelectListState, createSliderState, createStepListState, createTabListState, createTableCollection, createTableColumnResizeState, createTableState, createTextFieldState, createTimeFieldState, createTimeFieldState as useTimeFieldState, createToastQueue, createToastState, createToggleGroupState, createToggleState, createTokenFieldState, createTooltipTriggerState, createTreeCollection, createTreeData, createTreeGridState, createTreeState, defaultContainsFilter, endOfMonth, endOfWeek, endOfYear, getColorChannels, getDayOfWeek, getItemCount, getKeysForDrag, getLocalTimeZone, getWeeksInMonth, isAccessor, isSameDay, isSameMonth, isSameYear, isServer, isToday, isWeekend, maxDate, mergeValidation, minDate, normalizeColor, now, parseAbsolute, parseAbsoluteToLocal, parseColor, parseDate, parseDateTime, parseTime, parseZonedDateTime, privateValidationStateProp, radioGroupSyncVersion, resetTooltipState, startOfMonth, startOfWeek, startOfYear, toCalendar, toCalendarDate, toCalendarDateTime, toTime, toZoned, today };
 
 //# sourceMappingURL=index.js.map