@solidjs/signals 2.0.0-beta.9 → 2.0.0-rc.1

package/dist/prod/store/next/target.js

@@ -0,0 +1,20 @@
+/**
+ * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
+ * backings serving both the production identity-skip guard and the false
+ * no-mutation oracle.
+ */
+const ownedRaw = new WeakSet;
+
+/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
+
+function devAssertNeverUserMutation(o) {
+    return;
+}
+
+let optHooks = null;
+
+function setOptHooks(o) {
+    optHooks = o;
+}
+
+export { devAssertNeverUserMutation, optHooks, ownedRaw, setOptHooks, storeNextLookup };

package/dist/prod/store/store.js

@@ -0,0 +1,325 @@
+import "../core/core.js";
+
+import { GlobalQueue } from "../core/scheduler.js";
+
+import "../core/invariants.js";
+
+import "../core/verdict.js";
+
+import "../core/effect.js";
+
+import { storeNextLookup } from "./next/target.js";
+
+/**
+ * Brand symbols used internally by the store proxy / projection plumbing.
+ * Cross-package wiring; not part of the user-facing API.
+ *
+ * @internal
+ */ const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), // Node-map slot carrying a record-level `affects()` mark: any read through
+// the record witnesses it into the active isPending() probe.
+$AFFECTS = Symbol(0);
+
+// Structural field names of store targets (StoreNextTarget aliases these, so
+// shared machinery — affects walks, tests — reads targets via the consts).
+const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
+
+function lookupTarget(e, t) {
+    // Family maps (projections/optimistic) map raw -> target; the global next
+    // lookup maps raw -> target too. Proxies resolve through $TARGET directly.
+    if (t !== undefined) {
+        const o = t.get(e);
+        if (o !== undefined) return o[$TARGET] ?? o;
+    }
+    return storeNextLookup.get(e);
+}
+
+// Values marked raw never acquire a proxy identity: wrap() serves them as-is
+// everywhere — deep stores hold them as leaf values replaced by reference.
+// Once raw, always raw (identity stays single, just unwrapped). Consulted
+// only on wrap-creation and ingest paths; reads never touch it.
+const rawValues = new WeakSet;
+
+/**
+ * Marks a value as raw: no store will ever wrap it — every store presents it
+ * as-is, tracked by reference at whatever slot holds it and updated by
+ * replacement. Useful for class instances and external objects (editors,
+ * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
+ * for the value's lifetime.
+ */
+// Flipped on the first mark and exported as a LIVE binding: reconcile
+// consults it on every recursable pair, and importing the boolean directly
+// lets those sites skip even the function call when no shallow store or raw
+// mark exists anywhere in the app.
+let rawValuesUsed = false;
+
+function isRawValue(e) {
+    return rawValuesUsed && rawValues.has(e);
+}
+
+function markRawOne(e) {
+    if (isWrappable(e)) {
+        // A store proxy is already tracked elsewhere: the shallow boundary passes
+        // it through by reference (replaced, never edited — same slot semantics
+        // as a raw) instead of claiming it raw. The sticky mark is global, so
+        // marking a live proxy would make wrap() serve it verbatim through every
+        // OTHER store too — downstream deep stores then captured it instead of
+        // wrapping it in their own family, and their writes landed in the
+        // upstream store's override layer (#2932).
+        if (e[$TARGET] !== undefined) return;
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+}
+
+function markRawIngest(e) {
+    if (Array.isArray(e)) {
+        for (let t = 0, o = e.length; t < o; t++) markRawOne(e[t]);
+    } else {
+        for (const t in e) markRawOne(e[t]);
+    }
+}
+
+const OBJECT_PROTO = Object.prototype;
+
+// Per-prototype memo for the custom-proto branch of isWrappable: the verdict
+// is fully determined by the prototype (tag and Node lineage both live on
+// the chain), so each class pays the tag call once — not per read.
+const wrappableProtos = new WeakMap;
+
+function isWrappable(e) {
+    if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
+    // Plain data and user class instances wrap; platform objects never do
+    // (#2952). Native code brand-checks internal slots and throws through a
+    // proxy (`Map.prototype.size`, `Date.prototype.getTime`, ...), so
+    // collections and other built-ins can't honestly be stores — they get the
+    // markRaw-children contract automatically: served raw, mutations land raw,
+    // the property holding them still tracks (reassignment notifies). The tag
+    // check separates them structurally: user classes stringify as
+    // `[object Object]` while every native/host object carries its own brand
+    // (`[object Map]`, `[object Date]`, `[object Headers]`, ...), including
+    // subclasses, which inherit the tag. getPrototypeOf keeps the hot path
+    // (plain and null-proto objects) intrinsic-only — no property lookup.
+        const t = Object.getPrototypeOf(e);
+    if (t === OBJECT_PROTO || t === null) return true;
+    if (Array.isArray(e)) return true;
+    let o = wrappableProtos.get(t);
+    if (o === undefined) {
+        o = Object.prototype.toString.call(e) === "[object Object]" && (
+        // Dynamic Node check (kept dynamic so test/SSR overrides of
+        // `globalThis.Node` are observed at call time): shimmed DOMs implement
+        // nodes as plain user classes, which pass the tag check.
+        typeof Node === "undefined" || !(e instanceof Node));
+        wrappableProtos.set(t, o);
+    }
+    return o;
+}
+
+let writeOverride = false;
+
+function setWriteOverride(e) {
+    writeOverride = e;
+}
+
+function getWriteOverride() {
+    return writeOverride;
+}
+
+// Own enumerable keys including symbols (`Object.keys` drops symbol-keyed props). #2769
+function ownEnumerableKeys(e) {
+    return Reflect.ownKeys(e).filter(t => Object.prototype.propertyIsEnumerable.call(e, t));
+}
+
+/**
+ * Scope inheritance for late-created nodes: every live mark whose identity
+ * scope contains the owning record's raw — and, for keyed marks, whose key
+ * is this property — gets counted on the new node. Inherited marks live
+ * exactly as long as the scope's carrier — the release hook below drops
+ * them with the entry.
+ */ function inheritAffectsMarks(e, t, o) {
+    // A live scope exists, so affects.ts already installed the mark engine.
+    for (const [r, s] of affectsScopes) {
+        if (r.t && s.scope.has(t) && (s.key === undefined || s.key === o)) {
+            GlobalQueue.M(e);
+            s.inherited.push(e);
+        }
+    }
+}
+
+const affectsScopes = new Map;
+
+/** Next-store node factory for affects carriers/slots: injected by the
+ * rewrite module (next targets alias the legacy field names, so everything
+ * here EXCEPT node creation works on them structurally). */ let nextAffectsNodeResolver = null;
+
+function setNextAffectsNodeResolver(e) {
+    nextAffectsNodeResolver = e;
+}
+
+/** Next-store optimistic view for the declaration walk (optimistic rows
+ * pushed before the declaration are in motion too — legacy reads its write
+ * overlays; next composes armed-node overrides). */ let nextOptimisticViewResolver = null;
+
+function setNextOptimisticViewResolver(e) {
+    nextOptimisticViewResolver = e;
+}
+
+/** @internal birth inheritance for nodes created inside a live mark window —
+ * exported for the rewrite's node factories. */ function affectsScopesLive() {
+    return affectsScopes.size > 0;
+}
+
+/**
+ * Snapshots the identities reachable from `value` into `scope`, reading
+ * through write overlays (an optimistic row pushed before the declaration is
+ * in motion too). Untracked by construction: walks raw values, never traps.
+ * Every LIVE node under each reachable record — property leaves, `$TRACK`,
+ * and has-nodes — collects into `found`: those are the graph edges existing
+ * readers subscribed through, so the mark registers on them directly and
+ * rides the status rails to everything derived. (Nodes born later inherit
+ * from the scope in `getNode`.)
+ */ function walkAffectsScope(e, t, o, r, 
+// Cycle guard, fresh per declaration: the scope itself can't serve — a
+// re-declaration on the same carrier unions into a scope that already
+// holds the root, and must still descend to pick up records added since.
+s) {
+    if (!isWrappable(e)) return;
+    const f = e[$TARGET] || lookupTarget(e, r);
+    // Next targets: walk the pending backing when present (a draft's writes are
+    // in motion too) and cover BOTH identities in the scope.
+        let n = f ? f.pb ?? f[STORE_VALUE] : e;
+    if (s.has(n)) return;
+    s.add(n);
+    t.scope.add(n);
+    if (f && f.pb) t.scope.add(f[STORE_VALUE]);
+    // Next optimistic families: enumerate the VISIBLE view (armed-node
+    // overrides compose membership/values the raw doesn't carry).
+        if (f && f.fam?.opt && nextOptimisticViewResolver) n = nextOptimisticViewResolver(f, n);
+    if (f) {
+        collectRecordNodes(f[STORE_NODE], o);
+        collectRecordNodes(f[STORE_HAS], o);
+        // The key-set and deep-witness nodes are record-level channels: a deep()
+        // probe reads ONLY these (one pair per record), so a declared affects
+        // scope must mark them like any property node.
+                if (f.k) o.push(f.k);
+        if (f.dk) o.push(f.dk);
+        // Carry the effective lookup into untouched descendants (family maps for
+        // projections/optimistic stores; the global next lookup otherwise).
+                r = f.fam?.map ?? r ?? storeNextLookup;
+    }
+    // Overlays are gone (next has no layer): raw enumeration; the optimistic
+    // view composition above already folded armed-node membership/values in.
+        if (Array.isArray(n)) {
+        for (let e = 0, f = n.length; e < f; e++) {
+            walkAffectsScope(n[e], t, o, r, s);
+        }
+        const e = Object.getOwnPropertySymbols(n);
+        for (let f = 0, c = e.length; f < c; f++) {
+            const c = Object.getOwnPropertyDescriptor(n, e[f]);
+            if (!c || c.get) continue;
+            walkAffectsScope(c.value, t, o, r, s);
+        }
+    } else {
+        const e = Reflect.ownKeys(n);
+        for (let f = 0, c = e.length; f < c; f++) {
+            const c = Object.getOwnPropertyDescriptor(n, e[f]);
+            if (!c || c.get) continue;
+            walkAffectsScope(c.value, t, o, r, s);
+        }
+    }
+}
+
+/** All live signal nodes of one record's node map (string + symbol keyed). */ function collectRecordNodes(e, t) {
+    if (!e) return;
+    for (const o of Object.keys(e)) t.push(e[o]);
+    const o = Object.getOwnPropertySymbols(e);
+    for (let r = 0, s = o.length; r < s; r++) {
+        // Another mark's carrier is its own channel — counting it here would
+        // extend that sibling scope's lifetime to this declaration's.
+        if (o[r] !== $AFFECTS) t.push(e[o[r]]);
+    }
+}
+
+/**
+ * Witness live mark coverage of a record into the active isPending() probe.
+ * Tracked reads don't need this — they go through real signal nodes, which
+ * carry marks directly (declaration walk or birth inheritance). This covers
+ * UNTRACKED probes reading through records whose nodes never materialized
+ * (no observer ever subscribed, so no node exists to carry the mark).
+ * Callers guard on `pendingCheckActive`, so plain reads never pay for this.
+ *
+ * @internal
+ */ function witnessAffectsMark(e, t) {
+    // Callers guard on `pendingCheckActive`, which only flips inside
+    // isPending() — the verdict layer is loaded and its hook installed.
+    const o = e[STORE_NODE]?.[$AFFECTS];
+    if (o?.t) GlobalQueue.Lt(o);
+    if (affectsScopes.size) {
+        // Chained backings (§7b): a wrapper's STORE_VALUE can be another store's
+        // proxy — marks cover by identity of the BASE raw, so resolve the chain
+        // and check every identity along it.
+        let r = e[STORE_VALUE];
+        for (const [e, s] of affectsScopes) {
+            if (e !== o && e.t && (s.key === undefined || s.key === t)) {
+                let t = r;
+                for (;;) {
+                    if (s.scope.has(t)) {
+                        GlobalQueue.Lt(e);
+                        break;
+                    }
+                    const o = t?.[$TARGET];
+                    if (o === undefined) break;
+                    const r = o.pb ?? o[STORE_VALUE];
+                    if (r === t) break;
+                    t = r;
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Resolves the store nodes an `affects()` declaration marks: with a `key`,
+ * the named slot's leaf node (upserted so the mark has an addressable
+ * carrier); without, the record's $AFFECTS carrier plus every LIVE node in
+ * its subtree (the edges existing readers subscribed through), with the
+ * subtree's identities snapshotted into the mark's scope so nodes created
+ * during the window — and untracked probes over captured proxies — resolve
+ * against it (#2882).
+ *
+ * @internal
+ */ function getStoreAffectsNodes(e, t) {
+    GlobalQueue.p ||= e => {
+        const t = affectsScopes.get(e);
+        if (!t) return;
+        affectsScopes.delete(e);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.h(t.inherited[e]);
+    };
+    if (t === undefined) {
+        const t = nextAffectsNodeResolver(e, $AFFECTS);
+        let o = affectsScopes.get(t);
+        if (!o) affectsScopes.set(t, o = {
+            scope: new Set,
+            inherited: []
+        });
+        const r = [ t ];
+        walkAffectsScope(e[$PROXY], o, r, e.fam?.map, new Set);
+        return r;
+    }
+    const o = e.n?.[t] ?? nextAffectsNodeResolver(e, t);
+    // Keyed marks resolve by identity too (#2904): another store family's
+    // proxy can share this record's raw (a derived store swaps its backing to
+    // the source's raw when its projection lands), and reads through it never
+    // touch this target's node map. Scope is exactly the owning record's raw,
+    // narrowed to this key for witness and birth inheritance.
+        let r = affectsScopes.get(o);
+    if (!r) affectsScopes.set(o, r = {
+        scope: new Set,
+        inherited: [],
+        key: t
+    });
+    r.scope.add(e[STORE_VALUE]);
+    if (e.pb) r.scope.add(e.pb);
+    return [ o ];
+}
+
+export { $AFFECTS, $PROXY, $TARGET, $TRACK, STORE_HAS, STORE_NODE, STORE_VALUE, affectsScopesLive, getStoreAffectsNodes, getWriteOverride, inheritAffectsMarks, isRawValue, isWrappable, markRawIngest, markRawOne, nextAffectsNodeResolver, nextOptimisticViewResolver, ownEnumerableKeys, rawValuesUsed, setNextAffectsNodeResolver, setNextOptimisticViewResolver, setWriteOverride, witnessAffectsMark };

package/dist/prod/store/storePath.js

@@ -0,0 +1,103 @@
+import { isWrappable, ownEnumerableKeys } from "./store.js";
+
+const DELETE = Symbol(0);
+
+function isPrototypePollutionKey(t) {
+    return t === "__proto__" || t === "constructor" || t === "prototype";
+}
+
+function updatePath(t, e, o = 0) {
+    let r, n = t;
+    if (o < e.length - 1) {
+        r = e[o];
+        const i = typeof r;
+        const f = Array.isArray(t);
+        if (i === "string" && isPrototypePollutionKey(r)) return;
+        if (Array.isArray(r)) {
+            for (let n = 0; n < r.length; n++) {
+                e[o] = r[n];
+                updatePath(t, e, o);
+            }
+            e[o] = r;
+            return;
+        } else if (f && i === "function") {
+            for (let n = 0; n < t.length; n++) {
+                if (r(t[n], n)) {
+                    e[o] = n;
+                    updatePath(t, e, o);
+                }
+            }
+            e[o] = r;
+            return;
+        } else if (f && i === "object") {
+            const {from: n = 0, to: i = t.length - 1, by: f = 1} = r;
+            for (let r = n; r <= i; r += f) {
+                e[o] = r;
+                updatePath(t, e, o);
+            }
+            e[o] = r;
+            return;
+        } else if (o < e.length - 2) {
+            updatePath(t[r], e, o + 1);
+            return;
+        }
+        n = t[r];
+    }
+    let i = e[e.length - 1];
+    if (typeof i === "function") {
+        i = i(n);
+        if (i === n) return;
+    }
+    if (r === undefined && i == undefined) return;
+    if (i === DELETE) {
+        delete t[r];
+    } else if (r === undefined || isWrappable(n) && isWrappable(i) && !Array.isArray(i)) {
+        const e = r !== undefined ? t[r] : t;
+        const o = ownEnumerableKeys(i);
+        for (let t = 0; t < o.length; t++) {
+            const r = o[t];
+            if (typeof r === "string" && isPrototypePollutionKey(r)) continue;
+            const n = Object.getOwnPropertyDescriptor(i, r);
+            if (n.get || n.set) Object.defineProperty(e, r, n); else e[r] = n.value;
+        }
+    } else {
+        t[r] = i;
+    }
+}
+
+/**
+ * Path-based setter helper for `createStore`. Call `storePath(...path, value)`
+ * to produce a draft-mutating function suitable for passing to `setStore`.
+ *
+ * The canonical setter form in Solid 2.0 is the draft-mutating callback
+ * (`setStore(s => { s.user.name = "Ada"; })`). `storePath` is a backwards-
+ * compatibility helper for users porting from Solid 1.x's
+ * `setStore("user", "name", "Ada")` style — it's optional and you can mix the
+ * two styles freely.
+ *
+ * Path parts can be:
+ * - a single key — `"user"`, `0`
+ * - an array of keys — `[0, 1, 2]`
+ * - a range over an array — `{ from?, to?, by? }`
+ * - a filter `(item, index) => boolean` for arrays
+ *
+ * The final argument is the new value or an updater `(prev) => next`. Use
+ * `storePath.DELETE` to remove a property.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({ user: { name: "Ada" }, todos: [] });
+ *
+ * setState(storePath("user", "name", "Grace"));
+ * setState(storePath("todos", t => !t.done, "done", true)); // mark all undone as done
+ * setState(storePath("user", "nickname", storePath.DELETE));
+ * ```
+ */ const storePath = /* @__PURE__ */ Object.assign(function storePath(...t) {
+    return e => {
+        updatePath(e, t);
+    };
+}, {
+    DELETE: DELETE
+});
+
+export { storePath };

package/dist/prod/store/utils.js

@@ -0,0 +1,201 @@
+import "../core/core.js";
+
+import { SUPPORTS_PROXY } from "../core/constants.js";
+
+import "../core/scheduler.js";
+
+import "../core/invariants.js";
+
+import "../core/verdict.js";
+
+import "../core/effect.js";
+
+import { createMemo } from "../signals.js";
+
+import { ownEnumerableKeys, $PROXY } from "./store.js";
+
+function trueFn() {
+    return true;
+}
+
+const propTraps = {
+    get(e, r, t) {
+        if (r === $PROXY) return t;
+        return e.get(r);
+    },
+    has(e, r) {
+        if (r === $PROXY) return true;
+        return e.has(r);
+    },
+    set: trueFn,
+    deleteProperty: trueFn,
+    getOwnPropertyDescriptor(e, r) {
+        return {
+            configurable: true,
+            enumerable: true,
+            get() {
+                return e.get(r);
+            },
+            set: trueFn,
+            deleteProperty: trueFn
+        };
+    },
+    ownKeys(e) {
+        return e.keys();
+    }
+};
+
+function resolveSource(e) {
+    return !(e = typeof e === "function" ? e() : e) ? {} : e;
+}
+
+const $SOURCES = Symbol(0);
+
+/**
+ * Merges multiple props-like objects into a single proxy that *preserves
+ * reactivity*. Reads are forwarded to the right-most source that defines the
+ * property, so later sources override earlier ones (like `Object.assign`).
+ *
+ * Function arguments are treated as memo-backed sources — useful for passing
+ * derived defaults whose computation should track reactively.
+ *
+ * Use this in component bodies to merge defaults / overrides without losing
+ * Solid's per-property tracking.
+ *
+ * @example
+ * ```tsx
+ * function Button(_props: { label: string; type?: string; disabled?: boolean }) {
+ *   const props = merge({ type: "button", disabled: false }, _props);
+ *
+ *   return <button type={props.type} disabled={props.disabled}>{props.label}</button>;
+ * }
+ * ```
+ */ function merge(...e) {
+    if (e.length === 1 && typeof e[0] !== "function") return e[0];
+    let r = false;
+    const t = [];
+    for (let n = 0; n < e.length; n++) {
+        const o = e[n];
+        r = r || !!o && $PROXY in o;
+        const s = !!o && o[$SOURCES];
+        if (s) {
+            for (let e = 0; e < s.length; e++) t.push(s[e]);
+        } else t.push(typeof o === "function" ? (r = true, createMemo(o)) : o);
+    }
+    if (SUPPORTS_PROXY && r) {
+        return new Proxy({
+            get(e) {
+                if (e === $SOURCES) return t;
+                for (let r = t.length - 1; r >= 0; r--) {
+                    const n = resolveSource(t[r]);
+                    if (e in n) return n[e];
+                }
+            },
+            has(e) {
+                for (let r = t.length - 1; r >= 0; r--) {
+                    if (e in resolveSource(t[r])) return true;
+                }
+                return false;
+            },
+            keys() {
+                const e = new Set;
+                for (let r = 0; r < t.length; r++) {
+                    const n = ownEnumerableKeys(resolveSource(t[r]));
+                    for (let r = 0; r < n.length; r++) e.add(n[r]);
+                }
+                return [ ...e ];
+            }
+        }, propTraps);
+    }
+    const n = Object.create(null);
+    let o = false;
+    let s = t.length - 1;
+    for (let e = s; e >= 0; e--) {
+        const r = t[e];
+        if (!r) {
+            e === s && s--;
+            continue;
+        }
+        const u = Object.getOwnPropertyNames(r);
+        for (let t = u.length - 1; t >= 0; t--) {
+            const c = u[t];
+            if (c === "__proto__" || c === "constructor") continue;
+            if (!n[c]) {
+                o = o || e !== s;
+                const t = Object.getOwnPropertyDescriptor(r, c);
+                n[c] = t.get ? {
+                    enumerable: true,
+                    configurable: true,
+                    get: t.get.bind(r)
+                } : t;
+            }
+        }
+    }
+    if (!o) return t[s];
+    const u = {};
+    const c = Object.keys(n);
+    for (let e = c.length - 1; e >= 0; e--) {
+        const r = c[e], t = n[r];
+        if (t.get) Object.defineProperty(u, r, t); else u[r] = t.value;
+    }
+    u[$SOURCES] = t;
+    return u;
+}
+
+/**
+ * Returns a reactive proxy of `props` with the listed keys hidden. Tracking
+ * on the remaining keys is preserved.
+ *
+ * Use it to forward "rest" props to a child element while pulling out the
+ * keys your component handles itself — the equivalent of `splitProps(p, ["a","b"])[1]`.
+ *
+ * @example
+ * ```tsx
+ * function Input(props: { label: string; value: string; onInput: (v: string) => void } & JSX.HTMLAttributes<HTMLInputElement>) {
+ *   const rest = omit(props, "label", "value", "onInput");
+ *
+ *   return (
+ *     <label>
+ *       {props.label}
+ *       <input
+ *         {...rest}
+ *         value={props.value}
+ *         onInput={e => props.onInput(e.currentTarget.value)}
+ *       />
+ *     </label>
+ *   );
+ * }
+ * ```
+ */ function omit(e, ...r) {
+    if (SUPPORTS_PROXY && $PROXY in e) {
+        return new Proxy({
+            get(t) {
+                // $SOURCES must not tunnel through the filter: merge() flattens
+                // whatever answers it, so forwarding would hand a re-merge the
+                // UNFILTERED sources of an underlying merge proxy and the omitted
+                // keys leak back in (#3014 — the SSR element-spread path re-merges
+                // static attributes with the rest object). Opaque here: merge
+                // composes omit proxies through their traps instead.
+                return t === $SOURCES || r.includes(t) ? undefined : e[t];
+            },
+            has(t) {
+                return t !== $SOURCES && !r.includes(t) && t in e;
+            },
+            keys() {
+                return ownEnumerableKeys(e).filter(e => !r.includes(e));
+            }
+        }, propTraps);
+    }
+    const t = {};
+    const n = Object.getOwnPropertyNames(e);
+    const o = r.length > 4 && n.length > r.length ? new Set(r) : undefined;
+    for (const s of n) {
+        if (o ? !o.has(s) : !r.includes(s)) {
+            const r = Object.getOwnPropertyDescriptor(e, s);
+            !r.get && !r.set && r.enumerable && r.writable && r.configurable ? t[s] = r.value : Object.defineProperty(t, s, r);
+        }
+    }
+    return t;
+}
+
+export { merge, omit };

package/dist/types/affects.d.ts

@@ -0,0 +1,47 @@
+import type { Accessor } from "./signals.js";
+import { type Store } from "./store/store.js";
+/**
+ * Declares that in-flight work will change the targeted data: the named
+ * slot(s) — and everything DERIVED from them — read as pending
+ * (`isPending` → `true`) from the declaration until the surrounding
+ * transaction settles or reverts. A mark lives on its own channel — a
+ * refcount on the marked node plus dep-graph reachability in the verdict
+ * layer — so the marked values themselves stay readable (a mark is a promise
+ * of change, not an absence of value), no reader ever suspends on one, and
+ * completion/settlement accounting never sees one. This is the declaration
+ * verb of the pending model — additive only. A mark can turn pending ON for
+ * data the graph can't see changing yet; nothing can turn pending OFF while
+ * a real change is in flight — a quiet `refresh()` re-ask under a mark still
+ * reads pending (declaring the reload is what makes it a real question).
+ *
+ * Targets:
+ * - `affects(store)` — a store proxy (any record, root or nested): every
+ *   record reachable from it at declaration time reads pending, including
+ *   through captured child proxies (e.g. `<For>` rows). Siblings are
+ *   untouched; records added after the declaration are not covered.
+ * - `affects(record, key)` — exactly the named slot of the record. One key
+ *   per call (keys do NOT form a path — target the owning record directly).
+ * - `affects(accessor)` — a source accessor (signal or memo): the source
+ *   reads pending.
+ *
+ * Typically called at the top of an `action` alongside optimistic writes —
+ * both are up-front declarations about the same mutation. Outside any
+ * transaction the mark is released at the end of the current flush.
+ *
+ * @example
+ * ```ts
+ * const send = action(function* (text: string) {
+ *   setState(s => { s.messages.push({ text, status: "sending" }); });
+ *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
+ *   yield api.send(text);
+ * });
+ *
+ * const reload = action(function* () {
+ *   affects(thing);      // the whole store pends…
+ *   refresh(thing);      // …over this otherwise-quiet re-ask
+ *   yield api.done();
+ * });
+ * ```
+ */
+export declare function affects(target: Accessor<unknown> | Store<object>): void;
+export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;