@solidjs/signals 2.0.0-rc.10 → 2.0.0-rc.13

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

@@ -14,7 +14,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" | "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" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "BEHAVIOR_CLAIM_DROPPED" | "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" | "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" | "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" | "SERVER_WRITE" | "REVEAL_IN_RENDER_TO_STRING" | "LAZY_ASSET_UNMAPPED" | "PRELOAD_DESCRIPTOR_INVALID" | "HEAD_TAG_INVALID" | "UNRECOGNIZED_INSERT_VALUE" | "UNSCOPED_HOLE_ALLOCATED_IDS" | "ATTRIBUTE_SLOT_POSITION" | "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"
@@ -210,6 +210,24 @@ export type RecordLive<K extends RecordType> = RecordTypes[K] extends {
     live: infer L;
 } ? L : never;
 export type RecordListener<K extends RecordType> = (event: RecordEvent<K>, live: RecordLive<K>) => void;
+/**
+ * What a `Records.subscribe` asks of the emitter beyond the record itself.
+ */
+export interface RecordSubscribeOptions {
+    /**
+     * Ask for the record's BODIES: the live handles that cost the emitter
+     * something per record to take, and are taken only while a listener of
+     * the type has asked — so a consumer that reads ids, statuses and
+     * timings (an APM adapter, the performance tracks) never pays for what a
+     * body viewer (devtools' network panel) reads. Accepted for any type, the
+     * channel being generic; meaningful today for `"call"`, whose
+     * `live.request` (a reconstruction of the dispatched request) and
+     * `live.response` (an unread clone, a transient double-buffer of the
+     * payload) are taken only under it — without it, the transport's own
+     * objects. An emitter asks with `observed(type, "bodies")`.
+     */
+    bodies?: boolean;
+}
 /**
  * The records channel — `OBSERVE.records`, on either platform: one place a
  * consumer (an APM adapter's `init()`, devtools, the diagnostics harness)
@@ -235,14 +253,28 @@ export interface Records {
      * Deliver `type` records as they complete; returns the unsubscribe. The
      * subscription is the channel's, not any emitter's: it outlives the
      * attribution engine's `enable()`/`disable()` cycles and is dropped only
-     * by its own unsubscribe.
+     * by its own unsubscribe. `options` asks the emitter for more than the
+     * record — see `RecordSubscribeOptions`. One entry per listener function:
+     * its options are read at its first subscription to the type, a repeat
+     * subscription of the same function changes nothing, and either disposer
+     * removes it. What an emitter takes is decided once per record from the
+     * union of the type's subscribers, so a listener without `bodies` that
+     * shares a call with one that asked receives the same `live` — the clone.
      */
-    subscribe<K extends RecordType>(type: K, listener: RecordListener<K>): () => void;
+    subscribe<K extends RecordType>(type: K, listener: RecordListener<K>, options?: RecordSubscribeOptions): () => void;
     /**
      * Whether anything is subscribed to `type` — an emitter's pre-check, so
      * a record nobody will hear costs nothing to not build (no clock read).
      */
     observed(type: RecordType): boolean;
+    /**
+     * Whether a listener of `type` asked for its bodies
+     * (`subscribe(type, listener, { bodies: true })`) — the emitter's
+     * pre-check for the live handles that cost something per record to take.
+     * `false` while every listener of the type is a plain one, and once the
+     * last body-wanting one unsubscribed.
+     */
+    observed(type: RecordType, facet: "bodies"): boolean;
     /**
      * Delivers a completed record to `type`'s listeners, synchronously: how a
      * runtime publishes. Snapshot semantics without a snapshot — the listener
@@ -299,11 +331,32 @@ export interface Observe {
      * and stores created under it are excluded subjects wherever their writes
      * come from (a click handler, an adapter callback), so writes need no
      * `runWithOwner` — and must not use one: a write under an owner is a write
-     * in an owned scope (REACTIVE_WRITE_IN_OWNED_SCOPE). Irrevocable for the
-     * owner's lifetime.
+     * in an owned scope (REACTIVE_WRITE_IN_OWNED_SCOPE). One mark per owner:
+     * a later `exclude` or `include` on the same owner replaces it, and
+     * `include` re-admits a subtree beneath it.
      */
     exclude(owner: Owner): void;
-    /** Whether `subject` sits under an excluded owner (itself included). */
+    /**
+     * Marks `owner`'s subtree as the app's again, beneath an excluded owner.
+     * The verdict for a subject is the NEAREST marked ancestor's (the subject
+     * itself included): an `include` under an `exclude` re-admits that
+     * subtree, an `exclude` under an `include` excludes it again, and the
+     * markers nest to any depth. For an observer that WRAPS the app it
+     * watches — a toolbar rendering `<DevToolbar><App/></DevToolbar>` — so
+     * the toolbar's own root is excluded and the app's root, created under
+     * it, is included back. Mark the root as it is created, as with
+     * `exclude`: the attribution engine caches each node's verdict the first
+     * time it asks and keeps it for the node's life, so a mark set after a
+     * node was judged does not reach it. Alone — with no excluded ancestor —
+     * an included owner is what it already was. One mark per owner: a later
+     * `exclude` or `include` on the same owner replaces it.
+     */
+    include(owner: Owner): void;
+    /**
+     * Whether `subject` sits under an excluded owner (itself included) — the
+     * nearest marked ancestor on its owner chain answers, with the one mark
+     * (the latest `exclude`/`include`) that owner carries.
+     */
     isExcluded(subject: DiagnosticSubject | null | undefined): boolean;
     /**
      * Root-first names of the owners enclosing `subject` (inclusive when the

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

@@ -12,5 +12,5 @@ export { flush, Queue, GlobalQueue, enforceLoadingBoundary, resetErrorHalt, type
 export type { InteractionRef, NavigationRef } from "./attribution-hooks.js";
 export { ROOT_ERROR_HOOK } from "./scheduler.js";
 export { configureClientErrors, type ClientErrorContext, type ClientErrorHook, type ClientErrorsConfig } from "./error-hooks.js";
-export { DEV, OBSERVE, setConsoleFooter, type AttributionSlot, type Dev, type Observe, type ServerObserve, type Records, type RecordTypes, type HostRecordTypes, type RecordType, type RecordEvent, type RecordLive, type RecordListener, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type DiagnosticListener, type Diagnostics, type DiagnosticSeverity, type DiagnosticSubject } from "./dev.js";
+export { DEV, OBSERVE, setConsoleFooter, type AttributionSlot, type Dev, type Observe, type ServerObserve, type Records, type RecordTypes, type HostRecordTypes, type RecordType, type RecordEvent, type RecordLive, type RecordListener, type RecordSubscribeOptions, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type DiagnosticListener, type Diagnostics, type DiagnosticSeverity, type DiagnosticSubject } from "./dev.js";
 export * from "./constants.js";

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

@@ -260,7 +260,11 @@ export declare class GlobalQueue extends Queue {
      * commit whatever its relation to the committed value — a landing equal to
      * committed still differs from the override — then _supersedeOverride
      * decides. Installed with the optimistic engine; only reachable on a node
-     * that has an override. */
+     * that has an override — or, from `mapArray` once a lane pass has run over
+     * the map, on a per-slot signal (never CONFIG_OPTIMISTIC): the slot arm
+     * publishes a lane pass's write as the slot's derived override, lands a
+     * plain pass's write over one, and is the plain `setSignal` otherwise (F1,
+     * see optimistic.ts landOnOverride). */
     static _landOnOverride: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
     flush(): void;

package/dist/types/index.d.ts

@@ -14,7 +14,7 @@ import { type Dev, type Observe } from "./core/index.js";
 export declare const OBSERVE: Observe | undefined;
 /** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */
 export declare const DEV: Dev | undefined;
-export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionSlot, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
+export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionSlot, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, RecordSubscribeOptions, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
 export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, refresh, resolve, until, onSettled, onCleanup } from "./signals.js";
 export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { affects } from "./affects.js";

package/dist/types/signals.d.ts

@@ -551,13 +551,30 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
 export declare function refresh<T>(target: Refreshable<T>): Promise<T extends (...args: any) => infer V ? V : T>;
 /** Falsy values a truthy predicate result is narrowed against. */
 export type Truthy<T> = Exclude<T, false | 0 | 0n | "" | null | undefined>;
+/**
+ * The global `AbortSignal` when the consumer's libs declare one (DOM,
+ * WebWorker, `@types/node`), else the surface `until` uses — so these
+ * declarations check under neither lib without widening the global type.
+ */
+type GlobalAbortSignal = typeof globalThis extends {
+    AbortSignal: {
+        prototype: infer S;
+    };
+} ? S : {
+    readonly aborted: boolean;
+    readonly reason: any;
+    addEventListener(type: "abort", listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: "abort", listener: () => void): void;
+};
 export interface UntilOptions {
     /** Reject with `TimeoutError` if the predicate has not turned truthy within
      * this many milliseconds. Strongly recommended when the confirming truth
      * arrives over a transport that can drop (sockets, subscriptions). */
     timeout?: number;
     /** Reject with `signal.reason` on abort. */
-    signal?: AbortSignal;
+    signal?: GlobalAbortSignal;
 }
 /**
  * Awaits a reactive predicate and resolves the first time it settles *truthy*,

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

@@ -16,8 +16,10 @@ export declare function bumpDeep(t: StoreNextTarget): void;
  * the real container (committed + overlay writes − deletes) that fold will
  * SWAP in as the committed backing, exactly as if the draft had started on
  * the clone path. Consumers that need a complete container (reconcile's
- * diff walks, drafts escaping into other storage) call this. */
-export declare function materializePB(target: StoreNextTarget): void;
+ * diff walks, drafts escaping into other storage) call this, and so does the
+ * commit itself when the fold changed the key set (overlayRebuilds). Returns
+ * the pending backing (the clone, or the pb as-is when not an overlay). */
+export declare function materializePB(target: StoreNextTarget): Record<PropertyKey, any>;
 /** Resolve the held committed view (#3074): answers the masked old backing
  * while the hold is live, and lazily clears a hold whose transition has
  * committed (transitions merge — resolve through currentTransition, same as

package/package.json

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