@solidjs/signals 2.0.0-rc.4 → 2.0.0-rc.5

package/dist/types-cjs/store/next/optimistic.d.cts

@@ -1,20 +1,23 @@
+import { type Transition } from "../../core/scheduler.cjs";
 import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.cjs";
-import type { StoreNextFamily, StoreNextTarget } from "./target.cjs";
+import type { StoreNextTarget } from "./target.cjs";
+/** #3164 fold: a stamped truth is HELD (masked from ordinary readers until
+ * the reveal) only while its transition is live AND retaining optimism —
+ * overrides are what make partial-coverage composition a tear. A plain
+ * async transition carries no overrides, so downstream computes must see
+ * staged values to converge (normal speculation). Resolves merges first:
+ * merge unions optimistic nodes/stores into the target. */
+export declare function transitionHoldsOptimism(transition: Transition): boolean;
 export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
 /** Diff the draft against the current OPTIMISTIC VIEW (committed + active
  * overrides — the same view the draft was seeded from) and emit engine writes
  * for exactly the changed keys. Visible-view diffing keeps no-op writes from
  * entangling lanes (RUL-10 / opt R38). */
 export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<PropertyKey, any>): void;
-/**
- * Landing consumption (RUL-2): fresh authoritative data supersedes every
- * tentative override in the family. Mirrors legacy clearProjectionOverride —
- * drop the override, clear lane/ownership, notify subscribers whose visible
- * value changes (reversion effects go to regular queues via the projection
- * write posture the caller holds).
- */
-export declare function consumeOverridesNext(fam: StoreNextFamily): void;
 /** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
  * view, lane values included; a fresh copy per call during pending windows —
- * RUL-12). Returns `src` untouched when no override is active on `t`. */
+ * RUL-12). Returns `src` untouched when no override is active on `t`.
+ * Authoritative-view reads (until()'s predicate) skip composition entirely:
+ * the predicate observes authoritative truth, never the caller's tentative
+ * overlay. (Write-side emission callers never run under such a compute.) */
 export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;

package/dist/types-cjs/store/next/projection.d.cts

@@ -5,4 +5,4 @@ export declare function createProjectionNext<T extends object = {}>(fn: (draft:
  * masks the recompute for the tick (core R31 — the manual write wins over a
  * same-flush dependency change). */
 export declare function createStoreDerivedNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];
-export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;
+export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void, value: T) => void, aroundDraftWrite?: (op: () => void) => void): Computed<void | T>;

package/dist/types-cjs/store/next/store.d.cts

@@ -30,9 +30,16 @@ export declare function materializePB(target: StoreNextTarget): void;
  * authoritative base (R21/R32).
  */
 export declare function adoptPB(target: StoreNextTarget, incoming: Record<PropertyKey, any>, eager?: boolean): void;
+/** Parked truth-staged pending backings (#3164 fold): a tentative draft that
+ * opens while a folded landing's backing is live moves the staged container
+ * here (see ensurePB); the tentative discard in notifyOptimisticWrites
+ * restores it in place of the usual null. */
+export declare const stagedTruthPB: WeakMap<StoreNextTarget, Record<PropertyKey, any>>;
 /** Same logical slot: both values resolve to one (re-pointed) child target —
  * adoption preserved identity, so the slot did not change (R9). */
 export declare function targetsEqual(ov: any, nv: any): boolean;
+export declare function arrayStructureChanged(old: any[], neu: any[]): boolean;
+export declare function membershipChanged(old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): boolean;
 /**
  * The fold diff walks SUBSCRIPTION KEYS ONLY (legacy parity: `for key in
  * nodes`): nodes exist exactly where something tracked, so unobserved data
@@ -62,6 +69,21 @@ export declare function runAuthoritative<T>(fn: () => T): T;
 /** Active optimistic override on an armed node (armed slot idles at
  * NOT_PENDING; undefined = unarmed plain node). */
 export declare function hasActiveOverride(node: Signal<any>): boolean;
+/** The reading computation is until()'s authoritative-view predicate — same
+ * source of truth as core read()'s A17 carve-out (`context`, which persists
+ * under untrack). optimisticView()'s composition gate consults exactly this:
+ * write-side machinery (patch emission, tentative re-application) must keep
+ * composing even when it runs inside an authoritative-write bracket. */
+export declare function authoritativeRead(): boolean;
+/** Serve-side authoritative gate: until()'s predicate PLUS truth authors —
+ * the projection derive's draft (wrapDraft trap brackets, runAuthoritative;
+ * the same posture pair ensurePB classifies drafts by). A source computing
+ * the next truth must never read its callers' tentative overlays: a derive
+ * continuation's `store.push` computing its index from an action's
+ * optimistic row landed truth in the wrong slot and corrupted committed
+ * state (#3108). Trap-level overlay serves gate on this so values, length,
+ * membership, and keys leave the authoritative view together. */
+export declare function authoritativeServe(): boolean;
 export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
 /** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
  * emits write-time notifications at outermost exit, applies returned

package/dist/types-cjs/store/next/target.d.cts

@@ -27,6 +27,17 @@ export interface StoreNextFamily {
     /** Targets currently carrying active node overrides (landing-consumption
      * walk, RUL-2: visible landed truth replaces optimism). */
     overlaid?: Set<any>;
+    /** Retaining transactions (#3164 fold ruling): every transaction that made
+     * an optimistic setter call on this family and may still be open. While
+     * any member is live, truth landings FOLD — they stage into the retaining
+     * transaction and reveal atomically at its settle, exactly like a signal
+     * landing under an active override. Dead members prune lazily at each
+     * landing (retainingTransition). */
+    rt?: Set<any>;
+    /** Normalized row-key fn (same resolution as the projection channels:
+     * `options.key`, "id" default, null = unkeyed). The staged-landing walk
+     * reads it: key-matched rows keep their proxy identity across a fold. */
+    key?: ((item: any) => any) | null;
     map: WeakMap<object, StoreNextTarget>;
     /** The projection computed — assigned after creation (accessor pattern). */
     node: Computed<any> | null;
@@ -159,6 +170,10 @@ export interface OptStoreHooks {
     notifyOptimisticWrites(t: any, pb: Record<PropertyKey, any>): void;
     optimisticView(t: any, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
     applyTentative(t: any, incoming: any, keyFn: ((item: any) => any) | null): void;
+    /** #3164 fold: does this live transaction still retain optimism (armed
+     * nodes or tracked stores)? Backs the held-truth masks in next/store.ts so
+     * plain-store bundles don't carry the transition-optimism probe. */
+    retainsOptimism(t: any): boolean;
 }
 export declare let optHooks: OptStoreHooks | null;
 export declare function setOptHooks(h: OptStoreHooks): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.4",
+  "version": "2.0.0-rc.5",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",