@solidjs/signals 0.9.8 → 0.9.9

package/dist/types/boundaries.d.ts

@@ -5,12 +5,13 @@ export interface BoundaryComputed<T> extends Computed<T> {
 }
 export declare class CollectionQueue extends Queue {
     _collectionType: number;
-    _nodes: Set<Effect<any>>;
+    _sources: Set<Computed<any>>;
     _disabled: Signal<boolean>;
     _initialized: boolean;
     constructor(type: number);
     run(type: number): void;
-    notify(node: Effect<any>, type: number, flags: number): boolean;
+    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
+    checkSources(): void;
 }
 export declare const enum BoundaryMode {
     VISIBLE = "visible",

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

@@ -1,5 +1,5 @@
 import { $REFRESH, NOT_PENDING } from "./constants.js";
-import { type IQueue, type Transition } from "./scheduler.js";
+import { type IQueue, type OptimisticLane, type Transition } from "./scheduler.js";
 export interface Disposable {
     (): void;
 }
@@ -30,6 +30,7 @@ export interface RawSignal<T> {
     _transition: Transition | null;
     _pendingValue: T | typeof NOT_PENDING;
     _optimistic?: boolean;
+    _optimisticLane?: OptimisticLane;
     _pendingSignal?: Signal<boolean>;
     _pendingValueComputed?: Computed<T>;
 }
@@ -62,7 +63,7 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _fn: (prev?: T) => T;
     _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
     _child: FirewallSignal<any> | null;
-    _notifyStatus?: () => void;
+    _notifyStatus?: (status?: number, error?: any) => void;
 }
 export interface Root extends Owner {
     _root: true;

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

@@ -1,6 +1,10 @@
 export declare class NotReadyError extends Error {
-    cause: any;
-    constructor(cause: any);
+    _source: any;
+    constructor(_source: any);
+}
+export declare class StatusError extends Error {
+    _source: any;
+    constructor(_source: any, original: any);
 }
 export declare class NoOwnerError extends Error {
     constructor();

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

@@ -4,9 +4,62 @@ export declare const dirtyQueue: Heap;
 export declare const zombieQueue: Heap;
 export declare let clock: number;
 export declare let activeTransition: Transition | null;
-export declare let optimisticReadActive: boolean;
 export declare let projectionWriteActive: boolean;
-export declare function setOptimisticReadActive(value: boolean): void;
+/**
+ * OptimisticLane represents the context for a single optimistic write.
+ * Each optimistic signal creates its own lane. Lanes merge when their
+ * dependency graphs overlap.
+ */
+export interface OptimisticLane {
+    _source: Signal<any>;
+    _pendingAsync: Set<Computed<any>>;
+    _effectQueues: [QueueCallback[], QueueCallback[]];
+    _mergedInto: OptimisticLane | null;
+    _transition: Transition | null;
+}
+export declare const activeLanes: Set<OptimisticLane>;
+export declare let currentOptimisticLane: OptimisticLane | null;
+export declare function setCurrentOptimisticLane(lane: OptimisticLane | null): void;
+/**
+ * Get an existing lane for a signal or create a new one.
+ * Reuses lane for multiple writes to the same signal.
+ */
+export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
+/**
+ * Union-find: find the root lane.
+ */
+export declare function findLane(lane: OptimisticLane): OptimisticLane;
+/**
+ * Merge two lanes when their dependency graphs overlap.
+ */
+export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane): OptimisticLane;
+/**
+ * Clear a signal's lane entry so the next getOrCreateLane creates a fresh lane.
+ * Used after merging a sub-lane (e.g., _pendingSignal) into a parent lane.
+ */
+export declare function clearLaneEntry(signal: Signal<any>): void;
+/**
+ * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
+ */
+export declare function resolveLane(el: {
+    _optimisticLane?: OptimisticLane;
+}): OptimisticLane | undefined;
+/**
+ * Check if a node has an active optimistic override (pending value differs from base).
+ */
+export declare function hasActiveOverride(el: {
+    _optimistic?: boolean;
+    _pendingValue?: any;
+}): boolean;
+/**
+ * Assign or merge a lane onto a node. At convergence points (node already has
+ * a different active lane), merge unless the node has an active override.
+ */
+export declare function assignOrMergeLane(el: {
+    _optimisticLane?: OptimisticLane;
+    _optimistic?: boolean;
+    _pendingValue?: any;
+}, sourceLane: OptimisticLane): void;
 export declare function setProjectionWriteActive(value: boolean): void;
 export type QueueCallback = (type: number) => void;
 type QueueStub = {
@@ -14,14 +67,14 @@ type QueueStub = {
     _children: QueueStub[];
 };
 export interface Transition {
-    time: number;
-    asyncNodes: Computed<any>[];
-    pendingNodes: Signal<any>[];
-    optimisticNodes: Signal<any>[];
-    optimisticStores: Set<any>;
-    actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
-    queueStash: QueueStub;
-    done: boolean | Transition;
+    _time: number;
+    _asyncNodes: Computed<any>[];
+    _pendingNodes: Signal<any>[];
+    _optimisticNodes: Signal<any>[];
+    _optimisticStores: Set<any>;
+    _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
+    _queueStash: QueueStub;
+    _done: boolean | Transition;
 }
 export declare function schedule(): void;
 export interface IQueue {
@@ -30,7 +83,7 @@ export interface IQueue {
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
     created: number;
-    notify(node: Computed<any>, mask: number, flags: number): boolean;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     stashQueues(stub: QueueStub): void;
     restoreQueues(stub: QueueStub): void;
     _parent: IQueue | null;
@@ -38,15 +91,12 @@ export interface IQueue {
 export declare class Queue implements IQueue {
     _parent: IQueue | null;
     _queues: [QueueCallback[], QueueCallback[]];
-    _optimisticQueues: [QueueCallback[], QueueCallback[]];
     _children: IQueue[];
     created: number;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
-    notify(node: Computed<any>, mask: number, flags: number): boolean;
-    private _runQueue;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     run(type: number): void;
-    runOptimistic(type: number): void;
     enqueue(type: number, fn: QueueCallback): void;
     stashQueues(stub: QueueStub): void;
     restoreQueues(stub: QueueStub): void;
@@ -60,7 +110,7 @@ export declare class GlobalQueue extends Queue {
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
     static _clearOptimisticStore: ((store: any) => void) | null;
     flush(): void;
-    notify(node: Computed<any>, mask: number, flags: number): boolean;
+    notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     initTransition(transition?: Transition | null): void;
 }
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "",
   "author": "Ryan Carniato",
   "license": "MIT",