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

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

@@ -27,12 +27,22 @@ export declare function settlePendingSource(el: Computed<any>, source?: Computed
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */
 export declare function releaseFlightTeardown(el: Computed<any>): void;
+/**
+ * Internal (not a package export): run `fn` when the current pass's flight
+ * is superseded, at the same instant as the iterator close above, instead of
+ * when the replacing pass commits (owner cleanups wait for that). Chains onto
+ * the node's teardown slot; fires once with it. A no-op unless the ambient
+ * owner is a computed in its own pass. `consumeIterator` fills the slot
+ * before its first pull, so a source opened in an async generator's body
+ * (`for await`) composes after the generator's close.
+ */
+export declare function onSupersede(fn: () => void): void;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void, onError?: (error: unknown, pending: boolean) => 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): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error: any): void;
 /** The dependents' half of `notifyStatus`: `el`'s status reaches each
  * subscriber as a propagated mark (or a re-derive). On its own for a store
  * family's leaves, which are not the derive's dependents — the family
  * propagates the derive's status from each leaf to the leaf's readers
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */
-export declare function propagateStatus(el: Computed<any>, status: number, error: any, downstreamBlockStatus?: boolean): void;
+export declare function propagateStatus(el: Computed<any>, status: number, error: any): void;

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

@@ -219,3 +219,8 @@ export declare const $REFRESH: unique symbol;
 export type Refreshable<T> = T & {
     readonly [$REFRESH]: any;
 };
+/** `Set` under a module binding. Bundlers mark a bare `new Set()` pure with
+ * a `/* @__PURE__ *\/` comment that survives minification (16 bytes a site);
+ * a construction through a binding carries none. Same constructor, so the
+ * same objects. */
+export declare const NewSet: SetConstructor;

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

@@ -45,6 +45,9 @@ export declare function ext(el: {
  * the boundary collects it and shows its fallback, and the pass is the
  * boundary's, not the tick's (A29's boundary exemption, #3540). */
 export declare function joinPass(c: Computed<any>, el: Signal<any> | Computed<any>): void;
+/** `joinPass` into the hold `t` (a folded guess's: store/optimistic.ts
+ * `foldedRead`, D-34) — a reader is never a render effect there. */
+export declare function joinPassAt(c: Computed<any>, t: Transaction): void;
 /** A node born into transaction `t`: held by it and never committed (A29,
  * ruling A) — uninitialized (born held), or a member of the frame one of its
  * held passes built (CONFIG_HELD_FRAME). Its branch exists only in `t`: it
@@ -65,13 +68,13 @@ export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val:
  * channel (`_x._notifyStatus`) went with them; effects are the only
  * display consumers.
  */
-export declare let effectStatusNotify: ((this: any, status?: number, error?: any) => void) | null;
+export declare let effectStatusNotify: ((this: any) => void) | null;
 export declare function setEffectStatusNotify(fn: NonNullable<typeof effectStatusNotify>): void;
 /** Resolve a node's status notifier: effect nodes (`_type` — EFFECT_PURE is
  * 0, and only effect literals carry the field) get the shared notifier.
  * Presence doubles as the "display consumer" membership test in the status
  * walks, exactly as the per-node field did when every effect carried one. */
-export declare function statusNotifierOf(el: any): ((this: any, status?: number, error?: any) => void) | undefined;
+export declare function statusNotifierOf(el: any): ((this: any) => void) | null;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /** A store slot node (CONFIG_SLOT_NODE): the whole node in ONE literal — the
@@ -117,14 +120,31 @@ export declare function exitCallback(): void;
  * its owner (a list pass removing a row, a branch switching away), so its
  * writes are imperative like an effect callback's (#4165). Kept apart from
  * `callbackDepth` because its sites cannot use try/finally (the frame would
- * survive into prod): a throwing cleanup leaves it raised, and dev.ts resets
- * it on the next microtask, which teardown — synchronous — never spans.
+ * survive into prod). A throwing cleanup is caught (owner.ts `runCleanup`);
+ * anything else escaping a teardown leaves it raised, and dev.ts resets it on
+ * the next microtask, which teardown — synchronous — never spans.
  */
 export declare let disposalDepth: number;
 export declare function enterDisposal(): void;
 export declare function exitDisposal(): void;
 export declare function resetDisposalDepth(): void;
-export declare function setStrictRead(v: string | false): string | false;
+/**
+ * Dev-only: the DOM event being dispatched when the open strict-read window
+ * opened (`globalThis.event`; null between dispatches and off the main
+ * thread's Window), or `ANY_EVENT` when the window did not record one. A DOM
+ * call made in an effect callback that dispatches events synchronously
+ * (`el.focus()`, `el.click()`, `dialog.showModal()`) runs that event's
+ * handlers inside the window; a handler is a one-shot snapshot whoever
+ * dispatched the event, so a read made while a different event is current is
+ * outside the window (#4235). Only queued effect runs record the event, read
+ * once per queue (the getter is costly under jsdom); `strictReadActive` is
+ * the check.
+ */
+export declare let strictReadEvent: unknown;
+export declare const dispatchingEvent: () => unknown;
+export declare function setStrictRead(v: string | false, event?: unknown): string | false;
+/** Dev-only: is the strict-read window open for a read made now? */
+export declare function strictReadActive(): boolean;
 /**
  * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
  * subscribe the current scope. Returns whatever `fn` returns.
@@ -239,7 +259,10 @@ export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function serve(el: Signal<any> | Computed<any>, c: Computed<any> | null): unknown;
 /** A pass read a staging of this flush: it derives from what the flush may
  * yet hold (REACTIVE_STAGED_READ — the seam decides). Lane work too (plan sec. 28, a
- * lane sees the screen plus its own guesses): the staging is the screen if
+ * lane sees the screen plus its own guesses) — a folded lane's only before
+ * the frame has a transaction (after, it reads the screen like a verdict
+ * reader, `stagedScreen` — a list pass never pairs a held length with the
+ * guess's rows, D-34): the staging is the screen if
  * the frame commits — one pass, the common case — and a held write if it
  * parks, which the seam repairs (`stagedReaders`): the pass re-derives on
  * the committed world and its lane's runs wait that round, so the held

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

@@ -16,7 +16,7 @@ export interface DevHooks {
  * `warn`/`error` as failures unless they opt in to `info`.
  */
 export type DiagnosticSeverity = "info" | "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_EFFECT_CALLBACK" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "LOADING_ON_OUTSIDE_HOLD" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "UNTRACKED_READ_AFTER_AWAIT" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "GRAPH_GROWTH" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WASTED_RECOMPUTE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "UNTRACKED_ASYNC_HANDLER" | "ABANDONED_FLIGHTS" | "FALLBACK_FLASH" | "STACKED_HOLDS" | "OPTIMISTIC_REVERTED" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY" | "SSR_RENDER_ERROR_CONTAINED" | "SSR_SUBTREE_ABANDONED" | "SSR_STREAM_ABANDONED" | "SSR_CLIENT_CONTENT_MASKED" | "LATE_HEADER_WRITE" | "SERVER_ERROR_SANITIZED" | "SSR_BOUNDARY_WATERFALL" | "SSR_UNDECLARED_LIVE_SOURCE" | "SSR_LIVE_HOLE_LATCHED" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "LOWERCASE_EVENT_ATTRIBUTE" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ASYNC_STORE_SETTER" | "STORE_WRITE_OUTSIDE_SETTER" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_EFFECT_CALLBACK" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "LOADING_ON_OUTSIDE_HOLD" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "UNTRACKED_READ_AFTER_AWAIT" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "GRAPH_GROWTH" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WASTED_RECOMPUTE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "UNTRACKED_ASYNC_HANDLER" | "ABANDONED_FLIGHTS" | "FALLBACK_FLASH" | "STACKED_HOLDS" | "OPTIMISTIC_REVERTED" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY" | "SSR_RENDER_ERROR_CONTAINED" | "SSR_SUBTREE_ABANDONED" | "SSR_STREAM_ABANDONED" | "SSR_CLIENT_CONTENT_MASKED" | "LATE_HEADER_WRITE" | "SERVER_ERROR_SANITIZED" | "SSR_BOUNDARY_WATERFALL" | "SSR_UNDECLARED_LIVE_SOURCE" | "SSR_LIVE_HOLE_LATCHED" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "LOWERCASE_EVENT_ATTRIBUTE" | "UNCOMMITTED_INPUT_OVERWRITTEN" | "FRAME_MARKER_CORRUPTED" | "DYNAMIC_ASYNC_COMPONENT";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph"
 /** Perceived responsiveness: the runtime behaved correctly but the user saw no feedback. */
  | "responsiveness"
@@ -472,6 +472,14 @@ export declare function ownerPath(subject: DiagnosticSubject | null | undefined)
  * own). Console output is a separate, dev-tier step — see `reportDiagnostic`.
  */
 export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">, subject?: DiagnosticSubject | null | undefined): DiagnosticEvent;
+/**
+ * The locating lines of a console report: `\n  in <App> › <TodoRow> › effect`
+ * (the owner path) and `\n  at src/App.tsx:18:3` (see `locationLine`), each
+ * when the entry carries it; `""` when it carries neither. Shared by
+ * `reportDiagnostic` and the sites that print their own console entry (the
+ * halt, which logs its cause beside the message).
+ */
+export declare function locationLines(entry: DiagnosticEvent): string;
 /**
  * The console face of a diagnostic — ONE entry per finding: the message, the
  * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the

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

@@ -52,5 +52,13 @@ export declare class NoOwnerError extends Error {
     constructor();
 }
 export declare class ContextNotFoundError extends Error {
-    constructor();
+    /**
+     * In dev, a read site passes the context (and whether a provider above set
+     * it to `undefined`) so the message can name it and say why it has no
+     * value (#4181). Read through `arguments` so production — where the message
+     * is empty — keeps the zero-parameter constructor byte for byte.
+     */
+    constructor(context?: {
+        id: symbol;
+    }, providedUndefined?: boolean);
 }

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

@@ -1,6 +1,10 @@
 import type { Computed, Disposable, Owner, Root } from "./types.js";
 export declare function markDisposal(el: Owner): void;
 export declare function dispose(node: Computed<unknown>): void;
+/** Runs a cleanup or `unobserved` hook; a throw is collected, not raised. @internal */
+export declare function runCleanup(fn: () => void): void;
+/** Rethrows the error `runCleanup` collected, once; `drop` discards it. @internal */
+export declare function rethrowCleanupError(drop?: boolean): void;
 export declare function disposeChildren(node: Owner, self?: boolean, zombie?: boolean): void;
 export declare function linkChild(parent: Owner, node: Owner): void;
 /**

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

@@ -1,3 +1,4 @@
+import { type DiagnosticSubject } from "./dev.js";
 import { type Heap } from "./heap.js";
 import type { Computed, Owner, Signal } from "./types.js";
 export declare let laneReadHook: ((c: Computed<any> | null, el: Signal<any> | Computed<any>) => unknown) | null;
@@ -79,6 +80,15 @@ export interface Transaction {
      * leaf reading a held lane that has not shown is a stale reader of it
      * (#3460); one reading a lane the seam has not judged yet is its work. */
     _held: boolean;
+    /** Lane: a current truth that differs folded beneath one of its keyed
+     * guesses (lanes.ts `laneWrite`, D-34) — the store's reader of it: a
+     * deriving pass outside the lane, or `latest()` (`c` null), is served
+     * the hold's world from its guesses; NOT_PENDING otherwise
+     * (store/optimistic.ts `foldedRead`). Unset until then; not
+     * `_`-prefixed: a new mangled name shifts every later one
+     * (scripts/mangle-props.mjs), which costs the floors bytes for a path
+     * only optimistic stores reach. */
+    folded?: (c: Computed<any> | null, el: Signal<any> | Computed<any>) => unknown;
     /** `affects()` marks declared in it (affects.ts): released at the landing.
      * Not nodes — a mark holds nothing (`blocked` never sees one). */
     _marks: Signal<any>[] | null;
@@ -202,7 +212,14 @@ export declare function setQuestion(q: number): void;
 export declare function nextQuestion(): number;
 export declare const MAINLINE_QUESTION = 2147483647;
 export declare let inEffectCallback: boolean;
-export declare function setEffectCallback(value: boolean): void;
+/** Dev-only: matches no event, so a window or phase holding it applies
+ * whatever event is current (see `strictReadEvent`, core.ts). */
+export declare const ANY_EVENT: {};
+/** Dev-only: the DOM event current when the effect phase was entered. A
+ * handler dispatched synchronously from that phase (`el.focus()`) runs under
+ * a different event and is not in it (#4235). */
+export declare let effectCallbackEvent: unknown;
+export declare function setEffectCallback(value: boolean, event?: unknown): void;
 export type QueueCallback = (type: number) => void;
 export declare function schedule(): void;
 /**
@@ -219,6 +236,13 @@ export declare function schedule(): void;
  */
 export declare const ROOT_ERROR_HOOK: unique symbol;
 export declare function haltReactivity(cause?: unknown): void;
+/**
+ * Dev: `haltReactivity`, located at `subject` — the computation the uncaught
+ * error escaped from — for the REACTIVITY_HALTED message's owner path. Call
+ * sites pick it in dev builds only (`haltReactivity(e)` in production), so
+ * production keeps the one-argument halt and its bytes unchanged.
+ */
+export declare function haltReactivityAt(cause: unknown, subject: DiagnosticSubject): void;
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */
 export declare function resetErrorHalt(): void;
 export interface IQueue {
@@ -252,10 +276,12 @@ export declare class GlobalQueue implements IQueue {
     static _storeWrappable: ((v: unknown) => boolean) | undefined;
     static _mark: ((node: Signal<any> | Computed<any>) => void) | undefined;
     static _witnessMark: (() => void) | undefined;
-    /** An older question's truth was held beneath a guess (lanes.ts
-     * `laneWrite`): the store re-bases an arrangement guess over it
-     * (store/optimistic.ts). */
-    static _laneRebase: ((el: Signal<any>, truth: unknown) => void) | undefined;
+    /** A truth landing on a guess (lanes.ts `laneWrite`), `older` when it
+     * answers an older question: the store re-bases an arrangement guess over
+     * it; a current one differing from a shown keyed arrangement guess folds
+     * beneath it instead of voiding it (D-34) — true: the lane stages it
+     * beneath (store/optimistic.ts). */
+    static _laneRebase: ((el: Signal<any>, truth: unknown, older: boolean) => boolean | void) | undefined;
     static _verdictLane: ((t: Transaction) => Transaction) | undefined;
     static _laneGuesses: ((t: Transaction) => Signal<any>[]) | undefined;
     /** `createDeferred` (deferred.ts): a deferred node with a flight up that
@@ -294,8 +320,8 @@ export declare class GlobalQueue implements IQueue {
  * or without the held read) owes nothing. A run this transaction stashed
  * for it is void (#3322: an effect has one value slot, and the stale pass
  * overwrote the value that run was for) — the re-derivation's run replaces
- * it. */
-export declare function reruns(u: Transaction): void;
+ * it. Truthy when an effect re-derives (`land`). */
+export declare function reruns(u: Transaction): unknown;
 /** The held runs join this flush's effect phase after its own runs (the
  * landing's re-passes, in height order): the frame's effects run as one
  * pass would have queued them — a shell re-derived at the landing before a
@@ -364,3 +390,8 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/** Dev-only: the DOM event current when the running effect queue started,
+ * or `ANY_EVENT` outside one. Read once per queue rather than once per
+ * effect (the getter is costly under jsdom); no event starts or ends between
+ * two effects of one synchronous queue (#4235). */
+export declare let queueEvent: unknown;

package/dist/types/from.d.ts

@@ -0,0 +1,47 @@
+/** The observer a `subscribe` call receives. */
+type FromObserver<T> = {
+    next(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type Teardown = (() => void) | {
+    unsubscribe(): void;
+} | void;
+/**
+ * Anything `from` accepts: a subscribe function
+ * (`(next, error, complete) => unsubscribe`), an object with
+ * `subscribe(observer)` (RxJS and TC39 Observables, including
+ * `Symbol.observable` / `"@@observable"` interop), or an AsyncIterable.
+ */
+export type FromSource<T> = ((next: (value: T) => void, error: (err: unknown) => void, complete: () => void) => Teardown) | {
+    subscribe(observer: FromObserver<T>): Teardown;
+} | AsyncIterable<T>;
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */
+export declare function from<T>(source: FromSource<T>): AsyncIterable<T>;
+export {};

package/dist/types/index.d.ts

@@ -26,6 +26,7 @@ export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
 export { affects } from "./affects.js";
 export { createDeferred } from "./deferred.js";
+export { from, type FromSource } from "./from.js";
 export { flatten } from "./flatten.js";
 export { createLoadingBoundary, createErrorBoundary } from "./boundaries.js";
 export { createRevealOrder, type RevealOrder } from "./reveal.js";

package/package.json

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