@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

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

@@ -1,11 +1,33 @@
 /**
- * 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.
+ * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
+ * privatized committed backings) carries its owning target under this
+ * enumerable symbol. One property write replaces the two weak-collection
+ * registrations (ownership set + raw→target map) a fresh object used to pay
+ * per draft — V8's identity-hash + ephemeron cost dominated the one-key
+ * write floor. Enumerable so a spread copy (the plain-data clone path) stays
+ * on the fast path and carries the stamp along.
+ *
+ * Owned backings are never user-reachable (`snapshot` copies them, the traps
+ * hide the key), so every raw key walk in the store must skip `$OWNER`, and
+ * ownership is answered by `isOwned` — a user object never carries it.
+ * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
  */
-const ownedRaw = new WeakSet;
+const $OWNER = Symbol(0);
 
-/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
+/** raw → target for UNOWNED backings (user-ingested, adopted); owned
+ * backings resolve through their `$OWNER` stamp. Boundary mechanism (O8). */ const storeNextLookup = new WeakMap;
+
+/** A backing the store allocated and may mutate in place. */ function isOwned(e) {
+    return e[$OWNER] !== undefined;
+}
+
+/** raw → target within a family (`null` = plain stores / the global map).
+ * The stamp answers for backings owned by a target OF THAT FAMILY; anything
+ * else (user objects, adoptees, another family's backings the family
+ * re-registered for its own wrapper) resolves through the family's map. */ function lookupTarget(e, o) {
+    const t = e[$OWNER];
+    return t !== undefined && t.fam === o ? t : (o?.map ?? storeNextLookup).get(e);
+}
 
 function devAssertNeverUserMutation(e) {
     return;
@@ -19,11 +41,11 @@ function setOptHooks(e) {
 
 /** Sticky descendants flag walk (§6d): reconcile's keyed pruning descends
  * only where subscriptions exist at/below. Nodes AND patches count. */ function markDescendants(e) {
-    let t = e;
-    while (t && !t.d) {
-        t.d = true;
-        t = t.u;
+    let o = e;
+    while (o && !o.d) {
+        o.d = true;
+        o = o.u;
     }
 }
 
-export { devAssertNeverUserMutation, markDescendants, optHooks, ownedRaw, setOptHooks, storeNextLookup };
+export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, optHooks, setOptHooks, storeNextLookup };

package/dist/prod/store/store.js

@@ -8,7 +8,7 @@ import "../core/verdict.js";
 
 import "../core/effect.js";
 
-import { storeNextLookup } from "./next/target.js";
+import { $OWNER, lookupTarget as lookupTarget$1 } from "./next/target.js";
 
 /**
  * Brand symbols used internally by the store proxy / projection plumbing.
@@ -24,13 +24,9 @@ $AFFECTS = Symbol(0);
 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);
+    // Family registrations (projections/optimistic) first, then the global
+    // next lookup. Proxies resolve through $TARGET directly.
+    return (t ? lookupTarget$1(e, t) : undefined) ?? lookupTarget$1(e, null);
 }
 
 // Values marked raw never acquire a proxy identity: wrap() serves them as-is
@@ -202,9 +198,9 @@ s) {
         // 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;
+        // Carry the effective family into untouched descendants (projections/
+        // optimistic stores register children under their family).
+                r = f.fam ?? r;
     }
     // Overlays are gone (next has no layer): raw enumeration; the optimistic
     // view composition above already folded armed-node membership/values in.
@@ -214,6 +210,7 @@ s) {
         }
         const e = Object.getOwnPropertySymbols(n);
         for (let f = 0, c = e.length; f < c; f++) {
+            if (e[f] === $OWNER) continue;
             const c = Object.getOwnPropertyDescriptor(n, e[f]);
             if (!c || c.get) continue;
             walkAffectsScope(c.value, t, o, r, s);
@@ -221,6 +218,7 @@ s) {
     } else {
         const e = Reflect.ownKeys(n);
         for (let f = 0, c = e.length; f < c; f++) {
+            if (e[f] === $OWNER) continue;
             const c = Object.getOwnPropertyDescriptor(n, e[f]);
             if (!c || c.get) continue;
             walkAffectsScope(c.value, t, o, r, s);
@@ -252,7 +250,7 @@ s) {
     // 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?.o?.t) GlobalQueue.Wt(o);
+    if (o?.o?.t) GlobalQueue.ri(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
@@ -263,7 +261,7 @@ s) {
                 let t = r;
                 for (;;) {
                     if (s.scope.has(t)) {
-                        GlobalQueue.Wt(e);
+                        GlobalQueue.ri(e);
                         break;
                     }
                     const o = t?.[$TARGET];
@@ -302,7 +300,7 @@ s) {
             inherited: []
         });
         const r = [ t ];
-        walkAffectsScope(e[$PROXY], o, r, e.fam?.map, new Set);
+        walkAffectsScope(e[$PROXY], o, r, e.fam, new Set);
         return r;
     }
     const o = e.n?.[t] ?? nextAffectsNodeResolver(e, t);

package/dist/prod/store/utils.js

@@ -51,6 +51,15 @@ function resolveSource(e) {
 
 const $SOURCES = Symbol(0);
 
+/** @internal The flattened sources behind a `merge()` PROXY, or undefined.
+ * Only the proxy form: its writes are no-ops, so the sources are the whole
+ * truth. merge()'s plain-object form also records `$SOURCES` (so nested
+ * merges flatten), but it is a real object callers may mutate afterwards
+ * (html's tagged templates assign props after spreading) — those own writes
+ * live on the object, not in the sources, so it must be read directly. */ function mergeSources(e) {
+    return e != null && e[$PROXY] === e ? e[$SOURCES] : undefined;
+}
+
 /**
  * Merges multiple props-like objects into a single proxy that *preserves
  * reactivity*. Reads are forwarded to the right-most source that defines the
@@ -77,9 +86,9 @@ const $SOURCES = Symbol(0);
     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]);
+        const u = !!o && o[$SOURCES];
+        if (u) {
+            for (let e = 0; e < u.length; e++) t.push(u[e]);
         } else t.push(typeof o === "function" ? (r = true, createMemo(o)) : o);
     }
     if (SUPPORTS_PROXY && r) {
@@ -109,21 +118,21 @@ const $SOURCES = Symbol(0);
     }
     const n = Object.create(null);
     let o = false;
-    let s = t.length - 1;
-    for (let e = s; e >= 0; e--) {
+    let u = t.length - 1;
+    for (let e = u; e >= 0; e--) {
         const r = t[e];
         if (!r) {
-            e === s && s--;
+            e === u && u--;
             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 ? {
+        const c = Object.getOwnPropertyNames(r);
+        for (let t = c.length - 1; t >= 0; t--) {
+            const s = c[t];
+            if (s === "__proto__" || s === "constructor") continue;
+            if (!n[s]) {
+                o = o || e !== u;
+                const t = Object.getOwnPropertyDescriptor(r, s);
+                n[s] = t.get ? {
                     enumerable: true,
                     configurable: true,
                     get: t.get.bind(r)
@@ -131,15 +140,15 @@ const $SOURCES = Symbol(0);
             }
         }
     }
-    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;
+    if (!o) return t[u];
+    const c = {};
+    const s = Object.keys(n);
+    for (let e = s.length - 1; e >= 0; e--) {
+        const r = s[e], t = n[r];
+        if (t.get) Object.defineProperty(c, r, t); else c[r] = t.value;
     }
-    u[$SOURCES] = t;
-    return u;
+    c[$SOURCES] = t;
+    return c;
 }
 
 /**
@@ -189,13 +198,13 @@ const $SOURCES = Symbol(0);
     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);
+    for (const u of n) {
+        if (o ? !o.has(u) : !r.includes(u)) {
+            const r = Object.getOwnPropertyDescriptor(e, u);
+            !r.get && !r.set && r.enumerable && r.writable && r.configurable ? t[u] = r.value : Object.defineProperty(t, u, r);
         }
     }
     return t;
 }
 
-export { merge, omit };
+export { merge, mergeSources, omit };

package/dist/types/attribution.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@solidjs/signals/attribution` — the "why did this run" engine.
+ *
+ * A separate entry on purpose: the core ships only the hook slot
+ * (`OBSERVE.attribution.install`) and the interaction frame
+ * (`OBSERVE.attribution.withInteraction`); the engine that turns hook facts
+ * into re-run explanations, cost tables, holds and feedback lives here, so an
+ * observe build carries it only when something imports this module. The dev
+ * and observe tiers resolve to this file; the prod tier resolves to
+ * `attribution.prod.ts`, an inert engine with the same surface, so app code
+ * can import it unconditionally.
+ */
+export { attribution } from "./core/attribution.js";
+export type { Acknowledgement, Attribution, AttributionFeedbackTables, AttributionOptions, AttributionRecords, AttributionRecordType, ChangeKind, ChangeOrigin, ChangeRecord, FallbackStats, FeedbackInteraction, FeedbackNavigation, FeedbackSource, FlightLink, FlightStats, HeldWrite, HoldEvent, InteractionEvent, NavigationEvent, NavigationHop, RerunEvent, ScopeCost, WaterfallRecord, WriteCost } from "./core/attribution.js";
+export type { InteractionRef, NavigationRef, OriginRef } from "./core/attribution-hooks.js";

package/dist/types/attribution.prod.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@solidjs/signals/attribution` as the prod tier resolves it.
+ *
+ * A prod build has no hook sites — `__OBSERVE__` folded every one out — so an
+ * engine installed there would never hear a fact. Rather than make apps guard
+ * the import per tier, prod resolves this inert twin: the same `Attribution`
+ * surface, every query empty, `enable()` a no-op. Type-checked against the
+ * real engine's interface so the two cannot drift.
+ */
+import type { Attribution } from "./core/attribution.js";
+export declare const attribution: Attribution;
+export type { Acknowledgement, Attribution, AttributionFeedbackTables, AttributionOptions, AttributionRecords, AttributionRecordType, ChangeKind, ChangeOrigin, ChangeRecord, FallbackStats, FeedbackInteraction, FeedbackNavigation, FeedbackSource, FlightLink, FlightStats, HeldWrite, HoldEvent, InteractionEvent, NavigationEvent, NavigationHop, RerunEvent, ScopeCost, WaterfallRecord, WriteCost } from "./core/attribution.js";
+export type { InteractionRef, NavigationRef, OriginRef } from "./core/attribution-hooks.js";

package/dist/types/core/async.d.ts

@@ -14,7 +14,7 @@ export declare function setPendingError(el: Computed<any>, source?: Computed<any
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
 export declare function releaseSettledDependents(el: Computed<any>): void;
 export declare function settleErroredDependents(el: Computed<any>, error: any): void;
-export declare function settlePendingSource(el: Computed<any>): void;
+export declare function settlePendingSource(el: Computed<any>, source?: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */
 export declare function releaseFlightTeardown(el: Computed<any>): void;

package/dist/types/core/attribution-hooks.d.ts

@@ -1,21 +1,47 @@
+import type { Transition } from "./scheduler.js";
 import type { Computed, Signal } from "./types.js";
 /**
- * Dev-only observability hook points for the reactive core.
+ * Observe-tier hook points for the reactive core.
  *
  * Core's obligation is to call these with true facts at the moments they
  * happen; ALL attribution semantics (stamps, cause chains, timings, warnings)
- * live in the engine that installs them (attribution.ts — same pattern as the
- * GlobalQueue._* feature slots). `attrHooks` is null unless an engine is
- * installed, so the disabled cost is one null check per site, and prod builds
- * fold every site out behind __DEV__.
+ * live in the engine that installs them — `@solidjs/signals/attribution`, a
+ * separate entry so an observe build that never enables it never ships it
+ * (same pattern as the GlobalQueue._* feature slots). `attrHooks` is null
+ * unless an engine is installed, so the disabled cost is one null check per
+ * site, and prod builds fold every site out behind __OBSERVE__.
  *
  * IMPORTANT for implementers of call sites: a hook call must never sit inside
  * a `try` block — rollup's tryCatchDeoptimization retains functions referenced
- * inside `try` even behind a folded __DEV__ guard, which re-couples the dev
+ * inside `try` even behind a folded __OBSERVE__ guard, which re-couples the
  * engine into prod bundles (#2883 harness). Set a local flag inside the try
  * and call the hook after the catch.
  */
 export interface AttributionHooks {
+    /**
+     * `withInteraction` opened a user-interaction frame: root writes until the
+     * matching `interactionEnd` were performed by the handler of `ref`. Frames
+     * nest strictly (synchronous dispatch), so the engine keeps a stack.
+     */
+    interactionStart(ref: InteractionRef): void;
+    interactionEnd(): void;
+    /**
+     * `withOrigin` opened a declared-origin frame: root writes until the
+     * matching `originEnd` are the unit of work `ref` describes (a router's
+     * navigation). Nests inside an interaction frame — a link click that
+     * navigates — or stands alone (a redirect from an action, a programmatic
+     * `navigate()`). Frames nest strictly, so the engine keeps a stack.
+     */
+    originStart(ref: OriginRef): void;
+    originEnd(): void;
+    /**
+     * A `flush()` drain finished: every batch it processed either committed
+     * (its effects have run) or was parked in a held transition (`holdStart`
+     * fired for it). Fires once per drain, after the loop — not per batch, and
+     * not for a `flush()` call that found nothing to do. Gives the engine the
+     * "committed, screen updated" instant for writes no transition ever held.
+     */
+    flushEnd(): void;
     /**
      * A recompute is starting; `el._deps` still holds the previous run's links.
      * Always paired with `recomputeEnd` (recompute has no early returns).
@@ -58,6 +84,157 @@ export interface AttributionHooks {
      * from the node's state against its asyncStart snapshot.
      */
     asyncEnd(el: Computed<any>, prev: unknown, value: unknown, direct: boolean): void;
+    /**
+     * An effect's imperative half (its effect callback) is about to run /
+     * has run. Both fire outside the run's try; `effectRunEnd` fires whether
+     * or not the callback threw. Writes between the two are the effect's.
+     */
+    effectRunStart(el: Computed<any>): void;
+    effectRunEnd(el: Computed<any>): void;
+    /**
+     * One synchronous step of an `action()` generator is about to run / has
+     * run (`it.next()`/`it.throw()` up to the next yield). `it` is the
+     * invocation's iterator — stable identity across its steps; `name` the
+     * generator function's name. Writes between the two are the action's.
+     */
+    actionStepStart(it: object, name: string | undefined): void;
+    actionStepEnd(it: object): void;
+    /**
+     * A flush found `t` incomplete (transitionComplete's false verdict): its
+     * writes stay staged and its queues are about to be parked. Fired BEFORE
+     * this flush's lane effects (the visible acknowledgers — isPending
+     * companions, optimistic values) run; `holdEnd` fires from the root
+     * stashQueues call after them, so effect runs between the two are runs that
+     * painted *during* the hold.
+     */
+    holdStart(t: Transition): void;
+    holdEnd(): void;
+    /**
+     * `t` was judged complete (transitionComplete's true verdict, before `_done`
+     * flips). Fired before its held writes commit, so `t._pendingNodes` still
+     * lists what was staged.
+     */
+    transitionSettled(t: Transition): void;
+    /** `outgoing` was folded into `target` (`outgoing._done = target`). */
+    transitionMerged(target: Transition, outgoing: Transition): void;
+    /**
+     * A store setter batch replaced the container at `path` (e.g. `store.user`)
+     * with a different one (both non-null, same array-ness, not the same
+     * logical slot), and this is the leaf census of the new container against
+     * the old: `total` leaves (own keys, or items) in the new one, `unchanged`
+     * of which are the same value as before (identity, judged on unwrapped
+     * values — object keys compared by key, array items by membership), and
+     * `prevTotal` leaves in the old one. Containers above 64 leaves are not
+     * announced. Fired per written key from the write channel's notify. The
+     * engine decides whether the replacement was a spread-copy worth a
+     * diagnostic.
+     */
+    storeReplaced(path: string, isArray: boolean, total: number, unchanged: number, prevTotal: number): void;
+    /**
+     * A `mapArray` update both disposed and created rows: `removed` are the
+     * items whose rows were disposed, `created` the items that got new rows,
+     * `newLen` the list's new length, `keyed` whether a key function is in use
+     * (false = identity or by-index). Fired after commit. The engine judges
+     * whether the churn replaced equivalent records (unstable identity).
+     */
+    listChurn(el: Computed<any>, removed: unknown[], created: unknown[], newLen: number, keyed: boolean): void;
+    /**
+     * A loading boundary started (`shown` true) or stopped showing its
+     * fallback. `boundary` is the boundary's queue (stable identity); `tree`
+     * its bound subtree computed when already constructed — the first show can
+     * fire while the subtree is still being built — whose owner chain names
+     * the boundary. Fired at the source-set transitions (first pending source
+     * registers / last one clears), not per flush.
+     */
+    boundaryFallback(boundary: object, tree: Computed<any> | undefined, shown: boolean): void;
+}
+/** A user interaction, as a rendering runtime describes it to `withInteraction`. */
+export interface InteractionRef {
+    /** Event type — `click`, `keydown`, `input`… */
+    type: string;
+    /** The element hit, e.g. `button#next "Next →"`. */
+    target?: string;
+    /** Dispatch time on the `performance.now()` clock; defaults to now. */
+    at?: number;
+}
+/**
+ * A navigation, as a router describes it to `withOrigin` around the location
+ * write it is about to perform. Match eagerly and describe before writing:
+ * the engine keys the work the write causes — the hold behind route data,
+ * the re-runs, the verdicts — to this record, and names it by the
+ * parametrized route so occurrences fold together.
+ *
+ * The engine keeps the object and reads `name`, `to` and `params` again when
+ * the navigation settles (and when a hold on it is judged), so a router whose
+ * match is not final at write time — a lazy route subtree that resolves inside
+ * the hold — may describe coarsely (`/admin/*`) and assign the exact pattern
+ * and params onto the same object once it knows them. `from` and `at` are
+ * read once, when the frame opens.
+ */
+export interface NavigationRef {
+    kind: "navigation";
+    /** The matched route pattern — `/users/:id`. The name every consumer groups by. */
+    name?: string;
+    /** Concrete destination path. */
+    to?: string;
+    /** Concrete path being left. */
+    from?: string;
+    /** Route params the pattern bound — `{ id: "42" }` (optional params unbound: `undefined`). */
+    params?: Readonly<Record<string, string | undefined>>;
+    /**
+     * When the navigation was requested on the `performance.now()` clock;
+     * defaults to now. A router whose request predates the write (loaders
+     * awaited before the location moves) passes its own start here.
+     */
+    at?: number;
+    /**
+     * `>= 1`: this frame is the Nth redirect hop of the navigation still
+     * pending — a guard or loader sent it elsewhere before it landed — not a
+     * new navigation. The engine folds it onto that pending record: the record
+     * keeps the user's request time and interaction, its destination becomes
+     * this one, and the abandoned destination is kept in `redirects`. Without
+     * a pending navigation to fold onto it opens a navigation of its own.
+     */
+    redirect?: number;
 }
+/**
+ * What `withOrigin` accepts: a declared unit of work whose writes the engine
+ * should attribute as a whole. A discriminated union so kinds can be added
+ * (a form submission, a tab switch) without the seam changing shape; the
+ * engine knows `navigation` today.
+ */
+export type OriginRef = NavigationRef;
 export declare let attrHooks: AttributionHooks | null;
 export declare function setAttributionHooks(hooks: AttributionHooks | null): void;
+/**
+ * Run `fn` as the handler of a user interaction: every root write it performs
+ * (and every action step, effect or flight the write causes) is attributed to
+ * `ref` by whichever engine is installed. The web runtime wraps event
+ * dispatch in this; custom renderers and test harnesses call it themselves.
+ * With no engine installed it is `fn()` — the wiring, not the engine, so it
+ * lives in core and is reachable as `OBSERVE.attribution.withInteraction`.
+ *
+ * The `finally` is deliberate and safe under the try rule above: this
+ * function is referenced only from the `OBSERVE` object, which prod builds
+ * fold to `undefined`, so nothing retains it there.
+ */
+export declare function withInteraction<T>(ref: InteractionRef, fn: () => T): T;
+/**
+ * Run `fn` as a declared unit of work — a router's navigation: every root
+ * write it performs is attributed to `ref` (and, through it, to the enclosing
+ * interaction when there is one), so the hold those writes wait in, the
+ * re-runs they cause and the verdicts on them all carry the route's name
+ * instead of a bare signal's. Same contract as `withInteraction`: the wiring,
+ * not the engine; `fn()` with no engine installed. Reachable as
+ * `OBSERVE.attribution.withOrigin`.
+ *
+ * ```ts
+ * OBSERVE
+ *   ? OBSERVE.attribution.withOrigin(
+ *       { kind: "navigation", name: match.pattern, to, from, params: match.params },
+ *       () => setLocation(to)
+ *     )
+ *   : setLocation(to);
+ * ```
+ */
+export declare function withOrigin<T>(ref: OriginRef, fn: () => T): T;