2.0.0 | slow and steady wins the race

[mizulu]

Describe the bug

updating store ~4000 times, 2 keys at a time
takes ~3s to complete

 import { createStore, flush } from "solid-js"

 const COUNT = 4000
  const [store, setStore] = createStore({})
  const start = performance.now()

  for (
    let i = 1; i < COUNT; i++
  ) {
    setStore(store => {
      store[i - 1] = false
      store[i] = true
    })
    flush()
  }

  console.log(
    (performance.now() - start).toFixed(3),
    "ms"
  )

hot path

similar code in solid 1.x takes few ms for 100,000 updates
https://s.olid.uk/id/EGa-sTlDQuyeVbKU8nv3Sw

import { render } from 'solid-js/web';
import { createSignal, createEffect } from 'solid-js';

import { produce, createStore } from "solid-js/store"



const COUNT = 100000


const [store, setStore] = createStore({})


const start = performance.now()
for (
  let i = 1; i < COUNT; i++
) {
  queueMicrotask(() => {
    setStore(
      produce(store => {
        store[i - 1] = false
        store[i] = true
      })
    );

  })


}


console.log((performance.now() - start).toFixed(3) , "ms")

Your Example Website or App

https://s.olid.uk/id/r3tCfj0USguLi24fIhUXbg

Steps to Reproduce the Bug or Issue

see repro

Expected behavior

speed

Screenshots or Videos

No response

Platform

.

Additional context

No response

[mizulu]

function cloneRaw(source, t) {
  // Descriptor-preserving shallow clone (R29: installed getters stay live;
  // ruled 2026-08-17: frozen sources clone unfrozen — theirs stays frozen).
  // Data descriptors normalize to writable+configurable (the clone is OURS to
  // mutate — R51's "source-non-configurable is writable through the store");
  // enumerability and accessors are preserved. The scan doubles as the
  // accessor-flag detector (free — we're enumerating descriptors anyway).
  const descs = Object.getOwnPropertyDescriptors(source);
  for (const key of Reflect.ownKeys(descs)) {
    const d = descs[key];
    if (key === "length" && Array.isArray(source)) continue;
    d.configurable = true;
    if (!d.get && !d.set) d.writable = true;
    else if (t) t.a = true;
  }
  return Array.isArray(source)
    ? Object.defineProperties([], descs)
    : Object.create(Object.getPrototypeOf(source), descs);
}
function ensurePB(target) {
  let pb = target.pb;
  if (pb === null) {
    pb = target.pb = cloneRaw(target.v, target);
    // Optimistic families: seed USER drafts from the OPTIMISTIC VIEW
    // (committed + active node overrides), so follow-up writes compose on
    // optimism instead of clobbering from base (#2951's compose half).
    // AUTHORITATIVE drafts (projection recompute / write-override landings)
    // seed from committed truth — seeding overrides there would fold a lane
    // value into the committed home ("authority wins at reveal" would break).
    if (target.fam?.opt && !projectionWriteActive && !getWriteOverride()) {
      const nodes = target.n;
      if (nodes !== null) {
        for (const key of Reflect.ownKeys(nodes)) {
          const node = nodes[key];
          if (hasActiveOverride(node)) pb[key] = unwrapOverride(node._overrideValue);
        }
      }
      const has = target.h;
      if (has !== null) {
        for (const key of Reflect.ownKeys(has)) {
          const node = has[key];
          if (hasActiveOverride(node) && !unwrapOverride(node._overrideValue)) delete pb[key];
        }
      }
    }
    ownedRaw.add(pb);
    (target.fam?.map ?? storeNextLookup).set(pb, target);
    queueFold(target);
  }
  return pb;
}