@solidjs/signals 0.13.13 → 2.0.0-beta.7

package/dist/prod.js

@@ -666,6 +666,7 @@ function unobserved(e) {
     t = unlinkSubs(t);
   }
   e.C = null;
+  e.ge = null;
   disposeChildren(e, true);
 }
 function link(e, t) {
@@ -746,12 +747,12 @@ function disposeChildren(e, t = false, n) {
     e.ve = null;
   } else {
     e.Ce = null;
-    e.me = 0;
+    e.we = 0;
   }
   runDisposal(e, n);
 }
 function runDisposal(e, t) {
-  let n = t ? e.we : e.Ve;
+  let n = t ? e.me : e.Ve;
   if (!n) return;
   if (Array.isArray(n)) {
     for (let e = 0; e < n.length; e++) {
@@ -761,12 +762,12 @@ function runDisposal(e, t) {
   } else {
     n.call(n);
   }
-  t ? (e.we = null) : (e.Ve = null);
+  t ? (e.me = null) : (e.Ve = null);
 }
 function childId(e, t) {
   let n = e;
   while (n.be && n.i) n = n.i;
-  if (n.id != null) return formatId(n.id, t ? n.me++ : n.me);
+  if (n.id != null) return formatId(n.id, t ? n.we++ : n.we);
   throw new Error("Cannot get child id from owner without an id");
 }
 function getNextChildId(e) {
@@ -810,8 +811,8 @@ function createOwner(e) {
     Ve: null,
     F: t?.F ?? globalQueue,
     Le: t?.Le || defaultContext,
-    me: 0,
-    we: null,
+    we: 0,
+    me: null,
     ve: null,
     i: t,
     dispose(e = true) {
@@ -1200,11 +1201,11 @@ function recompute(e, t = false) {
     if (e.K || n === EFFECT_TRACKED) disposeChildren(e);
     else {
       markDisposal(e);
-      e.we = e.Ve;
+      e.me = e.Ve;
       e.ve = e.Ce;
       e.Ve = null;
       e.Ce = null;
-      e.me = 0;
+      e.we = 0;
     }
   }
   const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
@@ -1314,12 +1315,12 @@ function computed(e, t, n) {
     id: n?.id ?? (i ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
     be: i || undefined,
     ke: n?.equals != null ? n.equals : isEqual,
-    le: !!n?.pureWrite,
+    le: !!n?.ownedWrite,
     Ne: n?.unobserved,
     Ve: null,
     F: context?.F ?? globalQueue,
     Le: context?.Le ?? defaultContext,
-    me: 0,
+    we: 0,
     L: e,
     J: t,
     o: 0,
@@ -1337,7 +1338,7 @@ function computed(e, t, n) {
     Se: STATUS_UNINITIALIZED,
     Ee: clock,
     X: NOT_PENDING,
-    we: null,
+    me: null,
     ve: null,
     ye: null,
     K: null
@@ -1356,7 +1357,7 @@ function computed(e, t, n) {
   if (s) r.o = s.o + 1;
   if (snapshotCaptureActive && ownerInSnapshotScope(context)) r.Te = true;
   if (externalSourceConfig) {
-    const e = signal(undefined, { equals: false, pureWrite: true });
+    const e = signal(undefined, { equals: false, ownedWrite: true });
     const t = externalSourceConfig.factory(r.L, () => {
       setSignal(e, undefined);
     });
@@ -1378,7 +1379,7 @@ function computed(e, t, n) {
 function signal(e, t, n = null) {
   const i = {
     ke: t?.equals != null ? t.equals : isEqual,
-    le: !!t?.pureWrite,
+    le: !!t?.ownedWrite,
     He: !!t?.He,
     Ne: t?.unobserved,
     J: e,
@@ -1467,46 +1468,51 @@ function read(e) {
   }
   let t = context;
   if (t?.t) t = t.u;
-  if (refreshing && e.L) recompute(e);
-  if (e.O & REACTIVE_LAZY) {
-    e.O &= ~REACTIVE_LAZY;
-    recompute(e, true);
-  }
-  const n = e.V || e;
+  const n = e;
+  if (typeof n.L === "function") {
+    const t = e;
+    if (refreshing && !(t.O & REACTIVE_DISPOSED)) recompute(t);
+    if (t.O & REACTIVE_LAZY) {
+      t.O &= ~REACTIVE_LAZY;
+      recompute(t, true);
+    } else if (t.O & REACTIVE_DISPOSED) {
+      recompute(t, true);
+    }
+  }
+  const i = e.V || e;
   if (t && tracking) {
-    if (e.L && e.O & REACTIVE_DISPOSED) recompute(e);
     link(e, t);
-    if (n.L) {
-      const i = e.O & REACTIVE_ZOMBIE;
-      if (n.o >= (i ? zombieQueue.P : dirtyQueue.P)) {
+    if (i.L) {
+      const n = e.O & REACTIVE_ZOMBIE;
+      if (i.o >= (n ? zombieQueue.P : dirtyQueue.P)) {
         markNode(t);
-        markHeap(i ? zombieQueue : dirtyQueue);
-        updateIfNecessary(n);
+        markHeap(n ? zombieQueue : dirtyQueue);
+        updateIfNecessary(i);
       }
-      const r = n.o;
+      const r = i.o;
       if (r >= t.o && e.i !== t) {
         t.o = r + 1;
       }
     }
   }
-  if (n.Se & STATUS_PENDING) {
-    if (t && !(stale && n.K && activeTransition !== n.K)) {
+  if (i.Se & STATUS_PENDING) {
+    if (t && !(stale && i.K && activeTransition !== i.K)) {
       if (currentOptimisticLane) {
-        const i = n.q;
+        const n = i.q;
         const r = findLane(currentOptimisticLane);
-        if (i && findLane(i) === r && !hasActiveOverride(n)) {
+        if (n && findLane(n) === r && !hasActiveOverride(i)) {
           if (!tracking && e !== t) link(e, t);
-          throw n.fe;
+          throw i.fe;
         }
       } else {
         if (!tracking && e !== t) link(e, t);
-        throw n.fe;
+        throw i.fe;
       }
-    } else if (t && n !== e && n.Se & STATUS_UNINITIALIZED) {
+    } else if (t && i !== e && i.Se & STATUS_UNINITIALIZED) {
       if (!tracking && e !== t) link(e, t);
-      throw n.fe;
-    } else if (!t && n.Se & STATUS_UNINITIALIZED) {
-      throw n.fe;
+      throw i.fe;
+    } else if (!t && i.Se & STATUS_UNINITIALIZED) {
+      throw i.fe;
     }
   }
   if (e.L && e.Se & STATUS_ERROR) {
@@ -1528,13 +1534,26 @@ function read(e) {
     if (t && stale && shouldReadStashedOptimisticValue(e)) return e.J;
     return e.ee;
   }
-  return !t ||
+  const r =
+    !t ||
     (currentOptimisticLane !== null &&
-      (e.ee !== undefined || e.q || (n === e && stale) || !!(n.Se & STATUS_PENDING))) ||
+      (e.ee !== undefined || e.q || (i === e && stale) || !!(i.Se & STATUS_PENDING))) ||
     e.X === NOT_PENDING ||
     (stale && e.K && activeTransition !== e.K)
-    ? e.J
-    : e.X;
+      ? e.J
+      : e.X;
+  if (
+    !t &&
+    i === e &&
+    typeof n.L === "function" &&
+    !n.Pe &&
+    !(i.Se & STATUS_PENDING) &&
+    !n.i &&
+    !e.I
+  ) {
+    unobserved(e);
+  }
+  return r;
 }
 function setSignal(e, t) {
   if (e.K && activeTransition !== e.K) globalQueue.initTransition(e.K);
@@ -1588,7 +1607,7 @@ function runWithOwner(e, t) {
 }
 function getPendingSignal(e) {
   if (!e.Fe) {
-    e.Fe = optimisticSignal(false, { pureWrite: true });
+    e.Fe = optimisticSignal(false, { ownedWrite: true });
     if (e._e) {
       e.Fe._e = e;
     }
@@ -1875,23 +1894,24 @@ function accessor(e) {
   t.$r = true;
   return t;
 }
-function createSignal(e, t, n) {
+function createSignal(e, t) {
   if (typeof e === "function") {
-    const i = computed(e, t, n);
-    return [accessor(i), setSignal.bind(null, i)];
+    const n = computed(e, undefined, t);
+    n.Pe = true;
+    return [accessor(n), setSignal.bind(null, n)];
   }
-  const i = signal(e, t);
-  return [accessor(i), setSignal.bind(null, i)];
+  const n = signal(e, t);
+  return [accessor(n), setSignal.bind(null, n)];
 }
-function createMemo(e, t, n) {
-  let i = computed(e, t, n);
-  return accessor(i);
+function createMemo(e, t) {
+  let n = computed(e, undefined, t);
+  return accessor(n);
 }
-function createEffect(e, t, n, i) {
-  effect(e, t.effect || t, t.error, n, i);
+function createEffect(e, t, n) {
+  effect(e, t.effect || t, t.error, undefined, n);
 }
-function createRenderEffect(e, t, n, i) {
-  effect(e, t, undefined, n, { render: true, ...i });
+function createRenderEffect(e, t, n) {
+  effect(e, t, undefined, undefined, { render: true, ...n });
 }
 function createTrackedEffect(e, t) {
   trackedEffect(e, t);
@@ -1933,13 +1953,14 @@ function resolve(e) {
     });
   });
 }
-function createOptimistic(e, t, n) {
+function createOptimistic(e, t) {
   if (typeof e === "function") {
-    const i = optimisticComputed(e, t, n);
-    return [accessor(i), setSignal.bind(null, i)];
+    const n = optimisticComputed(e, undefined, t);
+    n.Pe = true;
+    return [accessor(n), setSignal.bind(null, n)];
   }
-  const i = optimisticSignal(e, t);
-  return [accessor(i), setSignal.bind(null, i)];
+  const n = optimisticSignal(e, t);
+  return [accessor(n), setSignal.bind(null, n)];
 }
 function onSettled(e) {
   const t = getOwner();
@@ -2086,7 +2107,7 @@ function reconcile(e, t) {
     applyState(e, n, i);
   };
 }
-function createProjectionInternal(e, t = {}, n) {
+function createProjectionInternal(e, t, n) {
   let i;
   const r = new WeakMap();
   const wrapper = e => {
@@ -2127,7 +2148,7 @@ function createProjectionInternal(e, t = {}, n) {
   i.Pe = true;
   return { store: s, node: i };
 }
-function createProjection(e, t = {}, n) {
+function createProjection(e, t, n) {
   return createProjectionInternal(e, t, n).store;
 }
 function createWriteTraps(e) {
@@ -2546,7 +2567,7 @@ function createStore(e, t, n) {
 function createOptimisticStore(e, t, n) {
   GlobalQueue.ce ||= clearOptimisticStore;
   const i = typeof e === "function";
-  const r = (i ? t : e) ?? {};
+  const r = i ? t : e;
   const s = i ? e : undefined;
   const { store: o } = createOptimisticProjectionInternal(s, r, n);
   return [o, e => storeSetter(o, e)];
@@ -2578,7 +2599,7 @@ function clearOptimisticStore(e) {
   }
   delete t[STORE_OPTIMISTIC_OVERRIDE];
 }
-function createOptimisticProjectionInternal(e, t = {}, n) {
+function createOptimisticProjectionInternal(e, t, n) {
   let i;
   const r = new WeakMap();
   const wrapper = e => {
@@ -2888,7 +2909,7 @@ function mapArray(e, t, n) {
   const i = typeof n?.keyed === "function" ? n.keyed : undefined;
   const r = t.length > 1;
   const s = t;
-  return createMemo(
+  const o = computed(
     updateKeyedMap.bind({
       Ye: createOwner(),
       Ze: 0,
@@ -2903,8 +2924,10 @@ function mapArray(e, t, n) {
       it: n?.fallback
     })
   );
+  o.Pe = true;
+  return accessor(o);
 }
-const pureOptions = { pureWrite: true };
+const pureOptions = { ownedWrite: true };
 function updateKeyedMap() {
   const e = this.Be() || [],
     t = e.length;
@@ -3026,17 +3049,21 @@ function updateKeyedMap() {
 }
 function repeat(e, t, n) {
   const i = t;
-  return updateRepeat.bind({
-    Ye: createOwner(),
-    Ze: 0,
-    rt: 0,
-    st: e,
-    Xe: i,
-    Je: [],
-    ze: [],
-    ot: n?.from,
-    it: n?.fallback
-  });
+  const r = computed(
+    updateRepeat.bind({
+      Ye: createOwner(),
+      Ze: 0,
+      rt: 0,
+      st: e,
+      Xe: i,
+      Je: [],
+      ze: [],
+      ot: n?.from,
+      it: n?.fallback
+    })
+  );
+  r.Pe = true;
+  return accessor(r);
 }
 function updateRepeat() {
   const e = this.st();
@@ -3134,8 +3161,8 @@ class RevealController {
   Ot;
   _t = [];
   dt;
-  ft = signal(false, { pureWrite: true, He: true });
-  Et = signal(false, { pureWrite: true, He: true });
+  ft = signal(false, { ownedWrite: true, He: true });
+  Et = signal(false, { ownedWrite: true, He: true });
   It = true;
   ht = false;
   constructor(e, t) {
@@ -3157,7 +3184,7 @@ class RevealController {
     if (this._t.includes(e)) return;
     this._t.push(e);
     const t = !!untrack(this.Rt);
-    setSignal(e.ft, true), setSignal(e.Et, t ? false : !!untrack(this.Ot));
+    (setSignal(e.ft, true), setSignal(e.Et, t ? false : !!untrack(this.Ot)));
     untrack(() => this.evaluate());
   }
   unregister(e) {
@@ -3198,8 +3225,8 @@ class CollectionQueue extends Queue {
   ct = new Set();
   Pt;
   lt = true;
-  ft = signal(false, { pureWrite: true, He: true });
-  Et = signal(false, { pureWrite: true, He: true });
+  ft = signal(false, { ownedWrite: true, He: true });
+  Et = signal(false, { ownedWrite: true, He: true });
   Tt;
   St = false;
   gt;
@@ -3295,7 +3322,7 @@ function createCollectionBoundary(e, t, n, i) {
   const c = computed(() => {
     if (!read(s.ft)) {
       const e = read(o);
-      if (!untrack(() => read(s.ft))) return (s.St = true), e;
+      if (!untrack(() => read(s.ft))) return ((s.St = true), e);
     }
     if (_revealUsed && read(s.Et)) return undefined;
     return n(s);

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

@@ -1,3 +1,4 @@
 import type { Computed, Link, Signal } from "./types.js";
 export declare function unlinkSubs(link: Link): Link | null;
+export declare function unobserved(el: Computed<unknown>): void;
 export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

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

@@ -16,7 +16,7 @@ export interface NodeOptions<T> {
     name?: string;
     transparent?: boolean;
     equals?: ((prev: T, next: T) => boolean) | false;
-    pureWrite?: boolean;
+    ownedWrite?: boolean;
     /** Exclude this signal from snapshot capture (internal — not part of public API) */
     _noSnapshot?: boolean;
     unobserved?: () => void;
@@ -29,7 +29,7 @@ export interface RawSignal<T> {
     _snapshotValue?: any;
     _name?: string;
     _equals: false | ((a: T, b: T) => boolean);
-    _pureWrite?: boolean;
+    _ownedWrite?: boolean;
     _noSnapshot?: boolean;
     _unobserved?: () => void;
     _time: number;

package/dist/types/signals.d.ts

@@ -29,7 +29,7 @@ export interface SignalOptions<T> {
     /** Custom equality function, or `false` to always notify subscribers */
     equals?: false | ((prev: T, next: T) => boolean);
     /** Suppress dev-mode warnings when writing inside an owned scope */
-    pureWrite?: boolean;
+    ownedWrite?: boolean;
     /** Callback invoked when the signal loses all subscribers */
     unobserved?: () => void;
 }
@@ -56,7 +56,7 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 /**
  * Creates a simple reactive state with a getter and setter.
  *
- * When called with a plain value, creates a signal with `SignalOptions` (name, equals, pureWrite, unobserved).
+ * When called with a plain value, creates a signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
  * When called with a function, creates a writable memo with `SignalOptions & MemoOptions` (adds id, lazy).
  *
  * ```typescript
@@ -74,52 +74,46 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  */
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+export declare function createSignal<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
  * Creates a readonly derived reactive memoized signal.
  *
  * ```typescript
- * const value = createMemo<T>(compute, initialValue?, options?: MemoOptions<T>);
+ * const value = createMemo<T>(compute, options?: MemoOptions<T>);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @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
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
-export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
-export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): Accessor<T>;
 /**
  * Creates a reactive effect that runs after the render phase.
  *
  * ```typescript
- * createEffect<T>(compute, effectFn | { effect, error }, initialValue?, options?: EffectOptions);
+ * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @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 value an optional initial value for the computation; if set, fn will never receive undefined as first argument
  * @param options `EffectOptions` -- name, defer
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
-export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
-export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.
  *
  * ```typescript
- * createRenderEffect<T>(compute, effectFn, initialValue?, options?: EffectOptions);
+ * createRenderEffect<T>(compute, effectFn, options?: EffectOptions);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @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 value an optional initial value for the computation; if set, fn will never receive undefined as first argument
  * @param options `EffectOptions` -- name, defer
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
  */
-export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next>): void;
-export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effectFn: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createRenderEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
@@ -159,14 +153,14 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
  * Creates an optimistic signal that can be used to optimistically update a value
  * and then revert it back to the previous value at end of transition.
  *
- * When called with a plain value, creates an optimistic signal with `SignalOptions` (name, equals, pureWrite, unobserved).
+ * When called with a plain value, creates an optimistic signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
  * When called with a function, creates a writable optimistic memo with `SignalOptions & MemoOptions` (adds id, lazy).
  *
  * ```typescript
  * // Plain optimistic signal
  * const [state, setState] = createOptimistic<T>(value, options?: SignalOptions<T>);
  * // Writable optimistic memo (function overload)
- * const [state, setState] = createOptimistic<T>(fn, initialValue?, options?: SignalOptions<T> & MemoOptions<T>);
+ * const [state, setState] = createOptimistic<T>(fn, options?: SignalOptions<T> & MemoOptions<T>);
  * ```
  * @param value initial value of the signal; if empty, the signal's type will automatically extended with undefined
  * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
@@ -177,7 +171,7 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
  */
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createOptimistic<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
  * Runs a callback after the current flush cycle completes.
  *

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

@@ -8,12 +8,12 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key, all).
  *
  * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
- * @param initial The initial value of the store.
+ * @param store The plain store value, or the backing seed when using the derived-store form.
  * @param options Optional projection options for reconciliation.
  *
  * @returns A tuple containing a store accessor and a setter function to apply changes.
  */
 export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
+export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
     [$REFRESH]: any;
 }, set: StoreSetter<T>];

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

@@ -1,6 +1,6 @@
 import { $REFRESH, type Computed } from "../core/index.js";
 import { type ProjectionOptions, type Store } from "./store.js";
-export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: ProjectionOptions): {
+export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
     store: Store<T> & {
         [$REFRESH]: any;
     };
@@ -11,15 +11,15 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  * draft and can mutate it directly or return a new value for reconciliation.
  *
  * ```typescript
- * const store = createProjection<T>(fn, initialValue?, options?: ProjectionOptions);
+ * const store = createProjection<T>(fn, seed, options?: ProjectionOptions);
  * ```
  * @param fn a function that receives the current draft and mutates it or returns new data
- * @param initialValue the initial store value (defaults to `{}`)
+ * @param seed the backing store host value to wrap and reconcile into
  * @param options `ProjectionOptions` -- name, key, all
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
-export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: ProjectionOptions): Store<T> & {
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Store<T> & {
     [$REFRESH]: any;
 };
 export declare function createWriteTraps(isActive?: () => boolean): ProxyHandler<any>;

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

@@ -54,7 +54,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * // Plain store
  * const [store, setStore] = createStore<T>(initialValue);
  * // Derived store (projection)
- * const [store, setStore] = createStore<T>(fn, initialValue?, options?: ProjectionOptions);
+ * const [store, setStore] = createStore<T>(fn, seed, options?: ProjectionOptions);
  * ```
  * @param store initial value to wrap in a reactive proxy, or a derive function
  * @param options `ProjectionOptions` -- name, key, all (only for derived stores)
@@ -62,7 +62,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
 export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
     [$REFRESH]: any;
 }, set: StoreSetter<T>];
 export {};

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

@@ -0,0 +1,52 @@
+import { Queue, type Computed, type Effect } from "./core/index.cjs";
+import type { Signal } from "./core/index.cjs";
+export interface BoundaryComputed<T> extends Computed<T> {
+    _propagationMask: number;
+}
+type RevealSlot = CollectionQueue | RevealController;
+type BoolAccessor = () => boolean;
+export declare class RevealController {
+    _togetherAccessor: BoolAccessor;
+    _collapsedAccessor: BoolAccessor;
+    _slots: RevealSlot[];
+    _parentController?: RevealController;
+    _disabled: Signal<boolean>;
+    _collapsed: Signal<boolean>;
+    _ready: boolean;
+    _evaluating: boolean;
+    constructor(together: BoolAccessor, collapsed: BoolAccessor);
+    _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
+    isReady(): boolean;
+    register(slot: RevealSlot): void;
+    unregister(slot: RevealSlot): void;
+    evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
+}
+export declare class CollectionQueue extends Queue {
+    _collectionType: number;
+    _sources: Set<Computed<any>>;
+    _tree?: BoundaryComputed<any>;
+    _pending: boolean;
+    _disabled: Signal<boolean>;
+    _collapsed: Signal<boolean>;
+    _revealController?: RevealController;
+    _initialized: boolean;
+    _onFn: (() => any) | undefined;
+    _prevOn: any;
+    constructor(type: number);
+    run(type: number): void;
+    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
+    checkSources(): void;
+}
+export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+    on?: () => any;
+}): import("./signals.cjs").Accessor<unknown>;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.cjs").Accessor<unknown>;
+export declare function createRevealOrder<T>(fn: () => T, options?: {
+    together?: BoolAccessor;
+    collapsed?: BoolAccessor;
+}): T;
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;
+export {};

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

@@ -0,0 +1 @@
+export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;

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

@@ -0,0 +1,6 @@
+import { type OptimisticLane } from "./lanes.cjs";
+import type { Computed } from "./types.cjs";
+export declare function settlePendingSource(el: Computed<any>): void;
+export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
+export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;