@solidjs/signals 2.0.0-beta.31 → 2.0.0-beta.33

package/dist/prod/map.js

@@ -37,7 +37,7 @@ function mapArray(t, s, i) {
     const o = computed(updateKeyedMap.bind(h));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        h.wt.Tt = o;
+        h.wt.dt = o;
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
@@ -235,18 +235,18 @@ function updateKeyedMap() {
         wt: createOwner(),
         jt: 0,
         Jt: 0,
-        Lt: t,
+        Vt: t,
         Kt: e,
         Ut: [],
         xt: [],
-        Vt: i?.from,
+        Xt: i?.from,
         Ht: i?.fallback
     };
     const n = computed(updateRepeat.bind(r));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        r.wt.Tt = n;
+        r.wt.dt = n;
     n.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
@@ -259,8 +259,8 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const t = this.Lt();
-    const s = this.Vt?.() || 0;
+    const t = this.Vt();
+    const s = this.Xt?.() || 0;
     runWithOwner(this.wt, () => {
         if (t === 0) {
             if (this.jt !== 0) {

package/dist/prod/signals.js

@@ -72,38 +72,6 @@ function createSignal(e, t) {
     return [ accessor(n), setSignal.bind(null, n) ];
 }
 
-/**
- * Creates a readonly derived reactive memoized signal.
- *
- * ```typescript
- * const value = createMemo<T>(compute, options?: MemoOptions<T>);
- * ```
- * @param compute a function that receives its previous value and returns a new value used to react on a computation
- * @param options `MemoOptions` -- id, name, equals, unobserved, lazy
- *
- * @example
- * ```ts
- * const [first, setFirst] = createSignal("Ada");
- * const [last, setLast] = createSignal("Lovelace");
- *
- * const fullName = createMemo(() => `${first()} ${last()}`);
- *
- * fullName(); // "Ada Lovelace"
- * ```
- *
- * @example
- * ```ts
- * // Async memo — reads surface as pending inside <Loading>
- * const user = createMemo(async () => {
- *   const res = await fetch(`/users/${id()}`);
- *   return res.json();
- * });
- * ```
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
- */
-// NoInfer keeps the previous-value parameter from influencing T inference, so
-// the memo/effect result type is still driven by the compute return type.
 function createMemo(e, t) {
     return accessor(computed(e, t));
 }
@@ -129,7 +97,7 @@ function createEffect(e, t, n) {
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects
- * @param options `EffectOptions` -- name, defer, schedule
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
  *
  * @example
  * ```ts
@@ -277,7 +245,7 @@ function createEffect(e, t, n) {
             // route through the inherited queue.
             const r = getOwner();
             const o = new MicrotaskQueue;
-            o.ve = r.C;
+            o.ke = r.C;
  // notify() forwards up the normal chain
                         r.C = o;
             // A user effect rather than a bare computed: computeds are pull-based and

package/dist/prod/store/optimistic.js

@@ -16,7 +16,7 @@ import { runProjectionComputed } from "./projection.js";
 
 import { $TARGET, STORE_FIREWALL, storeSetter, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_OPTIMISTIC } from "./store.js";
 
-function createOptimisticStore(e, t, r) {
+function createOptimisticStore(e, t, i) {
     // Register clear function with scheduler; store nodes marked
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
@@ -41,13 +41,13 @@ function createOptimisticStore(e, t, r) {
             return e(t);
         };
     }
-    const i = typeof e === "function";
+    const r = typeof e === "function";
     // Plain form: the second slot carries options.
-        if (!i && r === undefined) r = t;
-    const o = i ? t : e;
-    const n = i ? e : undefined;
+        if (!r && i === undefined) i = t;
+    const o = r ? t : e;
+    const n = r ? e : undefined;
     // Create optimistic projection store
-        const {store: c} = createOptimisticProjectionInternal(n, o, r);
+        const {store: c} = createOptimisticProjectionInternal(n, o, i);
     return [ c, e => storeSetter(c, e) ];
 }
 
@@ -56,8 +56,8 @@ function createOptimisticStore(e, t, r) {
 // scheduler's flush tail carries only a size-guarded hook call. The
 // completing transition scopes each clear to its own layer keys (#2899).
 function clearOptimisticStores(e, t) {
-    for (const r of e) {
-        const e = r[$TARGET];
+    for (const i of e) {
+        const e = i[$TARGET];
         if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e, t);
     }
     e.clear();
@@ -75,9 +75,9 @@ function clearOptimisticStores(e, t) {
  * fresh authoritative data) consumes everything — the correction supersedes
  * every tentative layer.
  */ function clearOptimisticOverride(e, t) {
-    const r = e[STORE_OPTIMISTIC_OVERRIDE];
-    if (!r) return;
-    const i = e[STORE_NODE];
+    const i = e[STORE_OPTIMISTIC_OVERRIDE];
+    if (!i) return;
+    const r = e[STORE_NODE];
     const o = e[STORE_OPTIMISTIC_OWNERS];
     const n = t !== undefined;
     let c = false;
@@ -87,7 +87,7 @@ function clearOptimisticStores(e, t) {
         const O = projectionWriteActive;
     setProjectionWriteActive(true);
     try {
-        for (const O of Reflect.ownKeys(r)) {
+        for (const O of Reflect.ownKeys(i)) {
             if (n) {
                 let e = o?.[O] ?? null;
                 // Resolve merge chains (entangled actions settle as one); path-compress
@@ -104,21 +104,21 @@ function clearOptimisticStores(e, t) {
                     }
                 }
             }
-            delete r[O];
+            delete i[O];
             if (o) delete o[O];
             c = true;
-            const T = i?.[O];
+            const T = r?.[O];
             if (T) {
                 // Clear lane association so effects go to regular queue
-                T.Me = undefined;
+                T.Ke = undefined;
                 // Re-read from base — this key left the optimistic layer above, so the
                 // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
                                 const t = getOverlayLayer(e, O);
-                const r = t ? t[O] : e[STORE_VALUE][O];
-                const i = r === $DELETED ? undefined : r;
-                const o = isWrappable(i) ? wrap(i, e) : i;
+                const i = t ? t[O] : e[STORE_VALUE][O];
+                const r = i === $DELETED ? undefined : i;
+                const o = isWrappable(r) ? wrap(r, e) : r;
                 const n = visibleNodeValue(T);
-                T.Ae = NOT_PENDING;
+                T._e = NOT_PENDING;
                 T.sn = null;
                 T.De = NOT_PENDING;
                 T.Ue = o;
@@ -135,8 +135,8 @@ function clearOptimisticStores(e, t) {
             e[STORE_OPTIMISTIC_OWNERS] = undefined;
         }
         // Notify $TRACK
-                if (c && i?.[$TRACK]) {
-            i[$TRACK].Me = undefined;
+                if (c && r?.[$TRACK]) {
+            r[$TRACK].Ke = undefined;
             notifySelf(e);
         }
     } finally {
@@ -144,10 +144,10 @@ function clearOptimisticStores(e, t) {
     }
 }
 
-function createOptimisticProjectionInternal(e, t, r) {
-    let i;
+function createOptimisticProjectionInternal(e, t, i) {
+    let r;
     const o = new WeakMap;
-    const n = !!r?.shallow;
+    const n = !!i?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
         e[STORE_LOOKUP] = o;
@@ -159,7 +159,7 @@ function createOptimisticProjectionInternal(e, t, r) {
  // Mark as optimistic store
                 Object.defineProperty(e, STORE_FIREWALL, {
             get() {
-                return i;
+                return r;
             },
             configurable: true
         });
@@ -193,19 +193,24 @@ function createOptimisticProjectionInternal(e, t, r) {
                 setProjectionWriteActive(t);
             }
         };
-        i = computed(() => {
+        // seedLoadingValue: born-committed firewall, same as createProjection.
+                let t;
+        if (i?.seedLoadingValue) t = {
+            loadingValue: undefined
+        };
+        r = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(c, e, r?.key === undefined ? "id" : r.key, wrapCommit, clearProjectionOverride);
+                runProjectionComputed(c, e, i?.key === undefined ? "id" : i.key, wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
-        }, undefined);
-        i.T &= ~CONFIG_AUTO_DISPOSE;
+        }, t);
+        r.T &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
         store: c,
-        node: i
+        node: r
     };
 }
 

package/dist/prod/store/projection.js

@@ -14,7 +14,7 @@ import { CONFIG_AUTO_DISPOSE } from "../core/constants.js";
 
 import { reconcileState } from "./reconcile.js";
 
-import { storeSetter, $TARGET, STORE_WRAP, createStoreProxy, storeTraps, setWriteOverride, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_VALUE, STORE_FIREWALL } from "./store.js";
+import { $TARGET, STORE_VALUE, storeSetter, STORE_WRAP, createStoreProxy, storeTraps, setWriteOverride, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_FIREWALL } from "./store.js";
 
 function createProjectionInternal(e, t, r) {
     let o;
@@ -44,10 +44,18 @@ function createProjectionInternal(e, t, r) {
         return t;
     };
     const c = wrapProjection(t);
+    // seedLoadingValue: the firewall is born committed (the seed is commit #0);
+    // the internal handleAsync serves it during the derive's first flight. The
+    // node's own value channel is void, so the loading value itself is
+    // `undefined` — presence of the key is what flips the mode.
+        let s;
+    if (r?.seedLoadingValue) s = {
+        loadingValue: undefined
+    };
     o = computed(() => {
         if (!o) o = getOwner();
         runProjectionComputed(c, e, r?.key === undefined ? "id" : r.key);
-    }, undefined);
+    }, s);
     o.T &= ~CONFIG_AUTO_DISPOSE;
     return {
         store: c,
@@ -122,16 +130,43 @@ function createProjectionInternal(e, t, r) {
     const i = getOwner();
     let c = false;
     let s;
-    const u = new Proxy(e, createWriteTraps(() => !c || i.Te === s, n));
-    storeSetter(u, n => {
-        s = t(n);
+    // Open loading window (seedLoadingValue): the observable store IS commit #0
+    // for the whole first flight, so the derive works a detached shadow of the
+    // seed — draft writes (pre-await, or between yields) land on the shadow and
+    // cannot tear through to readers (#2988; store reads resolve from the live
+    // backing, and the born-committed firewall removed the status gate that hid
+    // windowless drafts). Every commit point — sync return, each yield, the
+    // async landing — reconciles the shadow through the normal commit path, so
+    // a fully-sync derive still lands immediately (commit #0 superseded before
+    // any observer runs, same as a sync answer superseding loadingValue). The
+    // JSON round-trip matches the server's frozen-seed copy (seedLock): a
+    // loading-window seed is renderable data by contract. Optimistic note:
+    // onDraftWrite (override clearing) shifts from write-time to commit-time
+    // for the shadow run — an invisible draft write must not clobber a visible
+    // optimistic override mid-window.
+        const u = i.Ee ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
+    const a = new Proxy(e, createWriteTraps(() => !c || i.Te === s, n));
+    storeSetter(a, n => {
+        s = t(u ?? n);
         c = true;
         const commit = t => {
+            // Shadow run: a void/self return is the mutation form — the shadow
+            // carries the writes and is what commits. Commit a detached snapshot,
+            // never the shadow itself: reconcile adopts a new root value by
+            // identity, and handing it the live shadow would fuse the draft to the
+            // observable store — later shadow writes would mutate the backing
+            // silently and the next yield would diff the shadow against itself.
+            if (u && (t === undefined || t === u)) t = JSON.parse(JSON.stringify(u));
             if (t === n || t === undefined) return;
             const write = () => storeSetter(e, e => reconcileState(t, e, r, true));
             o ? o(write) : write();
         };
-        commit(handleAsync(i, s, commit));
+        const a = handleAsync(i, s, commit);
+        // A still-open window after handleAsync means the return was the
+        // commit-#0 fall-through, not a landing — real landings arrive through
+        // the setter. A closed one is a genuine sync landing (windowless nodes
+        // were never open); commit it.
+                if (!i.Ee) commit(a);
     });
     return i;
 }

package/dist/prod/store/store.js

@@ -291,7 +291,7 @@ function ownEnumerableKeysPlain(e) {
  * The value a store leaf's backing signal currently shows to readers: active
  * override, else held pending value, else committed value.
  */ function visibleNodeValue(e) {
-    return e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.De !== NOT_PENDING ? e.De : e.Ue;
+    return e._e !== undefined && e._e !== NOT_PENDING ? unwrapOverride(e._e) : e.De !== NOT_PENDING ? e.De : e.Ue;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -342,11 +342,11 @@ function getNode(e, t, r, n, o = isEqual, i) {
         }
     }, e[STORE_FIREWALL]);
     if (e[STORE_OPTIMISTIC]) {
-        O.Ae = NOT_PENDING;
+        O._e = NOT_PENDING;
     }
     if (i && r in i) {
         const e = i[r];
-        O.xe = e === undefined ? NO_SNAPSHOT : e;
+        O.Le = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources?.add(O);
     }
     if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS) symbolKeyedRecords.add(t);
@@ -464,11 +464,11 @@ o) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const r = e[STORE_NODE]?.[$AFFECTS];
-    if (r?.t) GlobalQueue.Gt(r);
+    if (r?.t) GlobalQueue.Lt(r);
     if (affectsScopes.size) {
         const n = e[STORE_VALUE];
         for (const [e, o] of affectsScopes) {
-            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Gt(e);
+            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Lt(e);
         }
     }
 }
@@ -610,8 +610,8 @@ function getPropertyDescriptor(e, t, r) {
 function prepareStoreWrite(e, t, r) {
     if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.Ie) {
-            globalQueue.initTransition(t.Ie);
+        if (t?.Ne) {
+            globalQueue.initTransition(t.Ne);
         }
     }
     const n = e[STORE_VALUE];

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

@@ -1,6 +1,15 @@
+import { NotReadyError } from "./error.js";
 import { type OptimisticLane } from "./lanes.js";
 import type { Computed, Link } from "./types.js";
 export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
+/**
+ * A loading-window node hit an unready source (sync throw in recompute, or a
+ * NotReadyError-rejected flight): register for the source's settle — the
+ * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
+ * with NO read-visible pending status, no downstream propagation, no
+ * transition, no lane registration. Commit #0 keeps serving.
+ */
+export declare function parkLoadingWindow(el: Computed<any>, e: NotReadyError): void;
 export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
 export declare function releaseSettledDependents(el: Computed<any>): void;

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

@@ -30,6 +30,16 @@ export interface NodeOptions<T> {
     unobserved?: () => void;
     lazy?: boolean;
     sync?: boolean;
+    /**
+     * Commit #0. When present (checked with `in`, so an explicit `undefined`
+     * counts), the node is born committed with this value instead of
+     * STATUS_UNINITIALIZED: reads serve it everywhere, nothing suspends to
+     * Loading boundaries, transitions are never held, and the window is
+     * verdict-quiet (`isPending` stays false — commit #0 answers the question
+     * by declaration; first-load affordances live in the value itself). After
+     * the first real answer lands, normal refetch/pending semantics apply.
+     */
+    loadingValue?: T;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
@@ -116,6 +126,20 @@ export interface Computed<T> extends RawSignal<T>, Owner {
      * (`clearStatus`). Meaningless while not STATUS_PENDING.
      */
     _reask: boolean;
+    /**
+     * True while a `loadingValue` node's first real answer hasn't landed: the
+     * node was born committed (commit #0 = the loading value) and `handleAsync`
+     * serves that committed value instead of throwing NotReadyError, so first
+     * flights never suspend readers, trip boundaries, or hold transitions.
+     * The window is verdict-quiet: `isPending` stays false, because commit #0
+     * answers the question by declaration (first-load affordances belong to
+     * the value channel). Cleared by the first value landing on any path (sync
+     * return, sync-resolved promise, first iterator yield, async settle); a
+     * real error leaves it set — errors answer reads but don't enter the value
+     * lineage, so a retry serves the loading value again. Once cleared, normal
+     * pending/refetch semantics apply forever.
+     */
+    _loading: boolean;
 }
 export interface Root extends Owner {
     _root: true;

package/dist/types/signals.d.ts

@@ -111,6 +111,28 @@ export interface EffectOptions extends BaseEffectOptions {
      * stored as-is and never awaited.
      */
     sync?: boolean;
+    /**
+     * Advanced (integration tier). When true, the effect is invisible to the
+     * hydration id scheme: it inherits its parent's id instead of consuming a
+     * child slot, and during hydration its compute runs live instead of
+     * adopting the serialized server value (its first run is not frozen to
+     * the server's decision).
+     *
+     * For **client-only effects created while hydrating** — effects with no
+     * server-rendered counterpart (a router wiring link state, scroll
+     * restoration, etc.). An id-consuming node the server never created would
+     * shift every later sibling's hydration id, making serialized lookups and
+     * template claims after it miss. `transparent` is also the supported
+     * alternative to branching on hydration state
+     * (`if (hydrating) createEffect(...)`), which freezes whatever the first
+     * run decided: create the effect unconditionally and let it observe live
+     * state instead.
+     *
+     * SSR ignores this option (a server-side effect always allocates its id
+     * slot), so only mark effects the server does not create. Outside
+     * hydration it is a no-op.
+     */
+    transparent?: boolean;
 }
 /** Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`. */
 export interface SignalOptions<T> {
@@ -138,7 +160,14 @@ export interface MemoOptions<T> {
     id?: string;
     /** Debug name (dev mode only) */
     name?: string;
-    /** When true, the owner is invisible to the ID scheme -- inherits parent ID and doesn't consume a childCount slot */
+    /**
+     * Advanced (integration tier). When true, the memo is invisible to the
+     * hydration id scheme: it inherits its parent's id instead of consuming a
+     * child slot, and during hydration it computes live instead of adopting
+     * the serialized server value. For client-only memos with no
+     * server-rendered counterpart — see {@link EffectOptions.transparent} for
+     * the full semantics. No-op outside hydration.
+     */
     transparent?: boolean;
     /**
      * Custom equality function, or `false` to always notify subscribers.
@@ -168,6 +197,30 @@ export interface MemoOptions<T> {
      * stored as-is and never awaited.
      */
     sync?: boolean;
+    /**
+     * Commit #0: a committed value the memo is born with, shown until the
+     * compute's first real answer lands. While that first answer is in flight
+     * the memo reads as a settled value everywhere — nothing suspends to a
+     * `<Loading>` boundary, no transition is held (first-flight work is
+     * loading-class, like a boundary fallback), and `isPending(memo)` stays
+     * **false**: commit #0 answers the question by declaration, so first-load
+     * affordances are driven from the value itself (a `null` placeholder, a
+     * `skeleton: true` field, etc.). Once the first answer lands, the loading
+     * value leaves the lineage forever: refetches use normal pending semantics
+     * (stale value shown, `isPending` true, boundaries/transitions coordinate)
+     * — the canonical guard is `data.skeleton || isPending(data)`, whose two
+     * terms cover the two disjoint states.
+     *
+     * Typed strictly as `T`: to use `null`/`undefined` as the placeholder,
+     * declare it in the memo's type (e.g. `createMemo<User | null>(...)`), so
+     * every consumer sees the nullable window honestly. If the placeholder is
+     * shaped data standing in for real data, encode its provenance in the data
+     * (e.g. a `skeleton: true` field) rather than letting it impersonate truth.
+     *
+     * The loading value is also the compute's first `prev`, so `prev`-based
+     * memos fold from it.
+     */
+    loadingValue?: T;
 }
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 /**
@@ -216,7 +269,7 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, options?: Signal
  * const value = createMemo<T>(compute, options?: MemoOptions<T>);
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
- * @param options `MemoOptions` -- id, name, equals, unobserved, lazy
+ * @param options `MemoOptions` -- id, name, equals, unobserved, lazy, transparent
  *
  * @example
  * ```ts
@@ -239,6 +292,9 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, options?: Signal
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
+export declare function createMemo<T>(compute: ComputeFunction<NoInfer<T>, T>, options: MemoOptions<T> & {
+    loadingValue: T;
+}): SourceAccessor<T>;
 export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): SourceAccessor<T>;
 /**
  * Creates a reactive effect with **separate compute and effect phases**.
@@ -280,7 +336,7 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects (return a cleanup function), or an `EffectBundle` with `effect` and `error` handlers
- * @param options `EffectOptions` -- name, defer, schedule
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
  *
  * @example
  * ```ts
@@ -334,7 +390,7 @@ export declare function createEffect<T>(compute: ComputeFunction<undefined | NoI
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects
- * @param options `EffectOptions` -- name, defer, schedule
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
  *
  * @example
  * ```ts

package/dist/types/store/store.d.ts

@@ -33,6 +33,20 @@ export interface ProjectionOptions extends StoreOptions {
     key?: string | ((item: NonNullable<any>) => any) | null;
     /** Single-layer store: root keys reactive, values raw records replaced by reference */
     shallow?: boolean;
+    /**
+     * Treat the seed as commit #0: the store is born committed with the seed's
+     * contents, shown until the derive's first real answer lands. While that
+     * first answer is in flight, reads serve the seed everywhere — nothing
+     * suspends to a `<Loading>` boundary, no transition is held, and
+     * `isPending` stays false (the seed answers by declaration; first-load
+     * affordances belong to the data, e.g. a `skeleton: true` field in the
+     * seed). Once the first answer lands (reconciled into the seed), refetches
+     * use normal pending semantics with `isPending` true.
+     *
+     * The store equivalent of `MemoOptions.loadingValue`; the seed already
+     * carries the placeholder shape, so this is just the opt-in.
+     */
+    seedLoadingValue?: boolean;
 }
 export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;

package/dist/types-cjs/core/async.d.cts

@@ -1,6 +1,15 @@
+import { NotReadyError } from "./error.cjs";
 import { type OptimisticLane } from "./lanes.cjs";
 import type { Computed, Link } from "./types.cjs";
 export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
+/**
+ * A loading-window node hit an unready source (sync throw in recompute, or a
+ * NotReadyError-rejected flight): register for the source's settle — the
+ * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
+ * with NO read-visible pending status, no downstream propagation, no
+ * transition, no lane registration. Commit #0 keeps serving.
+ */
+export declare function parkLoadingWindow(el: Computed<any>, e: NotReadyError): void;
 export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
 export declare function releaseSettledDependents(el: Computed<any>): void;

package/dist/types-cjs/core/types.d.cts

@@ -30,6 +30,16 @@ export interface NodeOptions<T> {
     unobserved?: () => void;
     lazy?: boolean;
     sync?: boolean;
+    /**
+     * Commit #0. When present (checked with `in`, so an explicit `undefined`
+     * counts), the node is born committed with this value instead of
+     * STATUS_UNINITIALIZED: reads serve it everywhere, nothing suspends to
+     * Loading boundaries, transitions are never held, and the window is
+     * verdict-quiet (`isPending` stays false — commit #0 answers the question
+     * by declaration; first-load affordances live in the value itself). After
+     * the first real answer lands, normal refetch/pending semantics apply.
+     */
+    loadingValue?: T;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
@@ -116,6 +126,20 @@ export interface Computed<T> extends RawSignal<T>, Owner {
      * (`clearStatus`). Meaningless while not STATUS_PENDING.
      */
     _reask: boolean;
+    /**
+     * True while a `loadingValue` node's first real answer hasn't landed: the
+     * node was born committed (commit #0 = the loading value) and `handleAsync`
+     * serves that committed value instead of throwing NotReadyError, so first
+     * flights never suspend readers, trip boundaries, or hold transitions.
+     * The window is verdict-quiet: `isPending` stays false, because commit #0
+     * answers the question by declaration (first-load affordances belong to
+     * the value channel). Cleared by the first value landing on any path (sync
+     * return, sync-resolved promise, first iterator yield, async settle); a
+     * real error leaves it set — errors answer reads but don't enter the value
+     * lineage, so a retry serves the loading value again. Once cleared, normal
+     * pending/refetch semantics apply forever.
+     */
+    _loading: boolean;
 }
 export interface Root extends Owner {
     _root: true;