@solidjs/signals 2.0.0-rc.15 → 2.0.0-rc.16

package/dist/types/map.d.ts

@@ -30,7 +30,7 @@ export type Maybe<T> = T | void | null | undefined | false;
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/map-array
  */
 export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
     keyed?: true;
@@ -62,7 +62,7 @@ export declare function __smallMoveHits(): number;
  * const view = repeat(count, i => `Item ${i}`, { fallback: () => "empty" });
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/jsx-component-primitives/repeat
  */
 export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
     from?: Accessor<number | undefined>;

package/dist/types/signals.d.ts

@@ -92,6 +92,13 @@ export type EffectBundle<Prev, Next extends Prev = Prev> = {
 interface BaseEffectOptions {
     /** Debug name (dev mode only) */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind beside `name`; dev and observe
+     * builds keep it for console reports and diagnostic events, production
+     * ignores it. Not meant to be written by hand.
+     */
+    loc?: string;
 }
 /** Options for effect primitives that support deferring/scheduling their initial run (`createEffect`, `createRenderEffect`, `createReaction`). */
 export interface EffectOptions extends BaseEffectOptions {
@@ -144,6 +151,13 @@ export interface EffectOptions extends BaseEffectOptions {
 export interface SignalOptions<T> {
     /** Debug name (dev mode only) */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind beside `name`; dev and observe
+     * builds keep it for console reports and diagnostic events, production
+     * ignores it. Not meant to be written by hand.
+     */
+    loc?: string;
     /**
      * Custom equality function, or `false` to always notify subscribers.
      * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
@@ -166,6 +180,13 @@ export interface MemoOptions<T> {
     id?: string;
     /** Debug name (dev mode only) */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind beside `name`; dev and observe
+     * builds keep it for console reports and diagnostic events, production
+     * ignores it. Not meant to be written by hand.
+     */
+    loc?: string;
     /**
      * Advanced (integration tier). When true, the memo is invisible to the
      * hydration id scheme: it inherits its parent's id instead of consuming a
@@ -275,7 +296,7 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  * setUser({ ...user(), name: "Alice" });
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-signal
  */
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
@@ -296,7 +317,7 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, options?: Signal
  * const [state, setState] = createOptimistic<T>(fn, options?: SignalOptions<T> & MemoOptions<T>);
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-optimistic-signal
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-optimistic
  */
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
@@ -329,7 +350,7 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-memo
  */
 export declare function createMemo<T>(compute: ComputeFunction<NoInfer<T>, T>, options: MemoOptions<T> & {
     loadingValue: T;
@@ -401,7 +422,7 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-effect
  */
 export declare function createEffect<const T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
@@ -431,7 +452,7 @@ export declare function createEffect<const T>(compute: ComputeFunction<undefined
  * }
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-render-effect
  */
 export declare function createRenderEffect<const T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
@@ -477,7 +498,7 @@ export declare function createRenderEffect<const T>(compute: ComputeFunction<und
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-tracked-effect
  */
 export declare function createTrackedEffect(compute: () => void | (() => void), options?: BaseEffectOptions): void;
 /**
@@ -504,7 +525,7 @@ export declare function createTrackedEffect(compute: () => void | (() => void),
  * setCount(1); // logs once, reaction re-armed for next change
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-reaction
  */
 export declare function createReaction(effectFn: EffectFunction<undefined> | EffectBundle<undefined>, options?: EffectOptions): (tracking: () => void) => void;
 /**

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

@@ -0,0 +1,9 @@
+/**
+ * @internal The name of the store `x` belongs to — `x` a store proxy (a
+ * setter's entry) or one of its property nodes (the setter notifying it) —
+ * or undefined when it has none or it cannot be placed: a projection or
+ * optimistic family, a store chained over another store's proxy, a root
+ * named twice, or a proxy reached through a store other than the one it
+ * was named as the root of.
+ */
+export declare function storeName(x: object | undefined): string | undefined;

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

@@ -3,14 +3,14 @@
  * (`createStore(fn, seed)`), projections, optimistic stores and reconcile
  * return on later steps (plan sec. 31.5).
  */
-export type { NoFn, NotWrappable, ProjectionOptions, ProjectionStoreReturn, SolidStore, Store, StoreOptions, StoreReturn, StoreSetter } from "./types.js";
+export type { NoArray, NoFn, NotWrappable, ProjectionOptions, ProjectionStoreReturn, SolidStore, Store, StoreOptions, StoreReturn, StoreSetter } from "./types.js";
 export { $PROXY, $RECORD, $TARGET, $TRACK, isWrappable, markRaw } from "./types.js";
 export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./store.js";
 export { storePath } from "./storePath.js";
 export type { StorePathRange, PathSetter, Part, CustomPartial, ArrayFilterFn } from "./storePath.js";
 import { createOptimisticStore } from "./optimistic.js";
 import { createProjection } from "./projection.js";
-import type { NoFn, ProjectionOptions, ProjectionStoreReturn, Store, StoreOptions, StoreReturn } from "./types.js";
+import type { NoArray, NoFn, ProjectionOptions, ProjectionStoreReturn, Store, StoreOptions, StoreReturn } from "./types.js";
 export { createOptimisticStore, createProjection };
 /** The store's internal record behind a proxy (`store[$TARGET]`). Kept
  * under `next`'s public name; its shape is the L2 target's (plan plan sec. 31–32:
@@ -23,9 +23,16 @@ export type { SourceKind } from "./utils.js";
  * Create a reactive store: a proxy over plain data with fine-grained
  * subscriptions per read path, written through its setter's draft — or, in
  * the derived form, a projection with a setter.
+ *
+ * The derived form comes in two shapes. Seedless, `createStore(fn)`: `fn`
+ * takes no draft and every answer is a complete `T` (plain-object roots only;
+ * pass `undefined` for the seed to reach the options). Seeded,
+ * `createStore(fn, seed)`: the seed is a complete `T` the derive drafts
+ * against — `[]` for an array.
  */
 export declare function createStore<T extends object = {}>(initialValue: NoFn<T>, options?: StoreOptions): StoreReturn<T>;
-export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): ProjectionStoreReturn<T>;
+export declare function createStore<T extends object = {}>(fn: (() => T | Promise<T> | AsyncIterable<T>) & NoArray<T>, seed?: null, options?: Omit<ProjectionOptions, "seedLoadingValue">): ProjectionStoreReturn<T>;
+export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): ProjectionStoreReturn<T>;
 /**
  * A setter transform that reconciles `value` into the store by key
  * (`"id"` by default; `null` positional), preserving store identity for

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

@@ -1,6 +1,6 @@
 import type { Refreshable } from "../core/index.js";
 import { type StoreTarget } from "./target.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "./types.js";
+import { type NoArray, type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "./types.js";
 export declare function notifyOptimisticWrites(t: StoreTarget, pb: Record<PropertyKey, any>): Record<PropertyKey, any> | null;
 export declare function sweepOverlaid(): void;
 /** An untracked `key in store` on an optimistic family: the presence guess
@@ -20,4 +20,5 @@ export declare function optimisticView(t: StoreTarget, src: Record<PropertyKey,
  * guess is what lands). */
 export declare function latestView(t: StoreTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
 export declare function createOptimisticStore<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (() => T | Promise<T> | AsyncIterable<T>) & NoArray<T>, seed?: null, options?: Omit<ProjectionOptions, "seedLoadingValue">): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];

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

@@ -1,6 +1,6 @@
 import type { Computed } from "../core/types.js";
 import type { Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store } from "./types.js";
+import { type NoArray, type NoFn, type ProjectionOptions, type Store } from "./types.js";
 /** The derive's pass: run `fn` against a draft of the store; commit its
  * result (sync, or each async landing) through the reconcile channel.
  * Draft validity is per run (R37): live from here until the NEXT run starts
@@ -13,6 +13,7 @@ export declare function runProjectionComputed<T extends object>(wrappedStore: St
  * firewall). `fn` may be async or an async iterator; the seed is a draft,
  * never an observable value, until the first landing (A25).
  */
-export declare function createProjection<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>>;
+export declare function createProjection<T extends object = {}>(fn: (() => T | Promise<T> | AsyncIterable<T>) & NoArray<T>, seed?: null, options?: Omit<ProjectionOptions, "seedLoadingValue">): Refreshable<Store<T>>;
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
 /** `createStore(fn, seed, options)`: a projection with a user setter. */
-export declare function createStoreDerived<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 createStoreDerived<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: T | null | undefined, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];

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

@@ -46,7 +46,7 @@ export declare function getHasNode(target: StoreTarget, key: PropertyKey): Signa
  * committed backing. */
 export declare function getContainerNode(target: StoreTarget): Signal<any>;
 export declare function bumpDeep(t: StoreTarget): void;
-export declare function nameStore(proxy: any, name: string | undefined): void;
+export declare function nameStore(proxy: any, name: string | undefined, loc?: string): void;
 /** Shallow clone into store ownership. Plain data (grade 2) spreads; anything
  * else copies descriptors (accessors kept, everything made configurable). */
 export declare function cloneRaw(source: Record<PropertyKey, any>, t: StoreTarget): Record<PropertyKey, any>;

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

@@ -42,6 +42,11 @@ export interface StoreFamily {
      * (`settleFamily`). A sync commit with no wake behind it walks nothing. */
     woke?: boolean;
 }
+/** One setter's written keys; `u` is the batch's earlier setters' (the
+ * fold's union), present only once a second setter writes the target. */
+export interface WrittenKeys extends Set<PropertyKey> {
+    u?: WrittenKeys;
+}
 export interface StoreTarget {
     /** Committed backing: source object (shared) or owned clone. */
     v: Record<PropertyKey, any>;
@@ -59,19 +64,22 @@ export interface StoreTarget {
     /** Lazy CONTAINER node: membership/iteration/`$TRACK`/`length`
      * subscriptions (§6) and the backing's staging home (plan sec. 31.3). */
     k: Signal<any> | null;
-    /** Keys written through the traps since the last fold commit. Bounds the
-     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
-     * a record with thousands of per-key subscriptions (selection maps) would
-     * otherwise pay a full node scan on every write. null = no trap writes
-     * this batch (bulk paths fall back to the full scan); WK_ALL = bound
-     * unusable (array length write). LOAD-BEARING SHAPE RULE: array proxy
-     * targets carry their fields as named properties on a real array, and V8
+    /** Keys written through the traps by the current setter, with the earlier
+     * setters' of the batch chained behind (`u`) until the fold commit. Bounds
+     * the setter notify/hold-check to O(written) instead of O(subscribed
+     * nodes) — a record with thousands of per-key subscriptions (selection
+     * maps) would otherwise pay a full node scan on every write — and to THIS
+     * setter's keys (D-8: a key an earlier setter of the batch wrote is told
+     * once, #3743). null = no trap writes this batch (bulk paths fall back to
+     * the full scan); WK_ALL = bound unusable (array length write).
+     * LOAD-BEARING SHAPE RULE: array proxy targets carry their fields as named
+     * properties on a real array, and V8
      * normalizes an array to dictionary properties as the named count grows
      * (empirically at counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap
      * field read then becomes a hash lookup (~15% uibench, tree suites
      * worst). Future write-side state MUST ride an extension object, not new
      * named fields. */
-    wk: Set<PropertyKey> | null;
+    wk: WrittenKeys | null;
     /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
      * of one per path; write paths bump it only when it exists. Separate from
      * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */

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

@@ -34,6 +34,13 @@ export interface StoreOptions {
      * projection node carries the name itself.
      */
     name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind; dev and observe builds keep it
+     * for console reports and diagnostic events, production ignores it. Not
+     * meant to be written by hand.
+     */
+    loc?: string;
     /** Single-layer store: root keys reactive, values raw records replaced by reference */
     shallow?: boolean;
 }
@@ -60,7 +67,14 @@ export interface ProjectionOptions extends StoreOptions {
      */
     seedLoadingValue?: boolean;
 }
+/** @internal */
 export type NoFn<T> = T extends Function ? never : T;
+/**
+ * Rejects array roots on the seedless derived form: a store's root shape is
+ * fixed when it is created, and `[]` is already a complete seed for an array.
+ * @internal
+ */
+export type NoArray<T> = Extract<T, readonly unknown[]> extends never ? unknown : never;
 /** Brand keys the proxy answers directly (never user data). */
 export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $RECORD: unique symbol;
 export declare namespace SolidStore {

package/package.json

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