@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.6

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

@@ -34,6 +34,16 @@ export interface StoreNextFamily {
      * landing under an active override. Dead members prune lazily at each
      * landing (retainingTransition). */
     rt?: Set<any>;
+    /** Flight-owned transaction (#3146): declared when a truth-flight
+     * registers (the ask's transaction — created by the flight's own pending
+     * throw when none was ambient, the causing write's when one was), renewed
+     * per settle event once the previous reveal committed. Bare optimistic
+     * writes and landings route into it BY DECLARATION; the transitionBlocked
+     * store-half checks it for ownership instead of reconstructing it from
+     * `_optimisticStores` membership. null = no flight declared one (sync
+     * derive, or a loading-window flight — the loading rail is
+     * transaction-invisible, #2933). */
+    ft?: any;
     /** Normalized row-key fn (same resolution as the projection channels:
      * `options.key`, "id" default, null = unkeyed). The staged-landing walk
      * reads it: key-matched rows keep their proxy identity across a fold. */

package/dist/types-cjs/core/attribution-hooks.d.cts

@@ -36,6 +36,17 @@ export interface AttributionHooks {
     write(el: Signal<any> | Computed<any>, prev: unknown, value: unknown): void;
     /** refresh() invalidated this node (self-invalidation, no dep changed). */
     refreshed(el: Computed<any>): void;
+    /**
+     * A new async flight entered the system (`_inFlight` was just assigned
+     * during a recompute of `el`). Always fired inside the owning recompute —
+     * both call paths (core's recompute and the projection self-registration)
+     * run within one — so the engine can read the current frame stack to link
+     * the flight to the change that caused it (waterfall chaining). `flight`
+     * is the registered thenable/iterable itself: the engine keys a first-seen
+     * origin registry on its identity, so shared and preloader-marked promises
+     * carry their true start time instead of the moment the graph saw them.
+     */
+    flightStart(el: Computed<any>, flight: object): void;
     /** An async landing is about to apply its value (before any branch). */
     asyncStart(el: Computed<any>): void;
     /**

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

@@ -143,6 +143,24 @@ export interface AttributionOptions {
      * disables.
      */
     wideWrites?: number | false;
+    /**
+     * Async-waterfall warning: emit a diagnostic when an async flight that
+     * could only start after an upstream flight resolved (its recompute's
+     * cause chain reaches the upstream's async landing, and its origin
+     * post-dates that landing) forms a sequential chain of 2+ flights, each
+     * of which took at least `minFlightMs` (default 50ms). The duration gate
+     * is one safety valve for what the graph cannot see: a settled
+     * preload/cache hit resolves fast and never warns. In-flight preloads are
+     * absolved by origin: `markFlight()` stamps (and first-seen identity)
+     * prove work predated the upstream landing — parallel, not sequential.
+     * Chains of 2 emit at `info` severity, structured channel only (a
+     * dependent fetch is sometimes intrinsic, and unmarked external preloads
+     * are invisible); 3+ escalate to `warn` with console output. `false`
+     * disables.
+     */
+    waterfalls?: {
+        minFlightMs: number;
+    } | false;
 }
 export interface ScopeCost {
     name: string;
@@ -186,6 +204,36 @@ export interface Attribution {
         scopes: ScopeCost[];
         writes: WriteCost[];
     };
+    /**
+     * Every graph-provable sequential flight chain observed since enable()
+     * (ring-buffered like history()). Facts, not verdicts: chains are recorded
+     * regardless of the duration gate — the ASYNC_WATERFALL diagnostic is the
+     * thresholded view of the same data.
+     */
+    waterfalls(): readonly WaterfallRecord[];
+    /**
+     * Cooperative preload declaration: stamp a flight object (promise or async
+     * iterable) with its true kickoff time BEFORE the reactive graph sees it.
+     * A route preloader or query cache calls this on the promise it hands out
+     * (on the WRAPPER it mints, with the original kickoff time — wrapping
+     * defeats identity tracking otherwise); any dependent that later awaits it
+     * is then judged against the real start — work already in the air when its
+     * upstream landed is parallel, never a waterfall link. Callable while
+     * attribution is disabled (marks made at navigation time must survive a
+     * later enable()). Dev-only, like the whole DEV surface.
+     */
+    markFlight(flight: object, startedAt?: number): void;
     format: typeof formatRerun;
 }
+/** One landed flight: its node name, wall duration, and upstream chain. */
+export interface FlightLink {
+    name: string;
+    ms: number;
+}
+export interface WaterfallRecord {
+    /** Sequential flights, oldest first, ending at the flight that landed. */
+    chain: FlightLink[];
+    /** Summed wall time of the chain — the serialized cost. */
+    sequentialMs: number;
+}
 export declare const attribution: Attribution;

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

@@ -6,8 +6,14 @@ export interface DevHooks {
     onUpdate?: () => void;
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
-export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WIDE_WRITE";
+/**
+ * `info` is the advisory tier: a structural fact worth surfacing that is not
+ * presumptively a bug (e.g. a 2-deep sequential fetch chain, which may be an
+ * intrinsic data dependency). Budget/assertion consumers should treat only
+ * `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" | "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" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WIDE_WRITE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph";
 /** First warning when a node's live edge count reaches this size. */
 export declare const GRAPH_SIZE_WARN_AT = 2000;

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

@@ -209,6 +209,11 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/** A fresh, unentered transaction (#3146): the optimistic store's truth
+ * flight DECLARES an owned transaction instead of relying on whatever the
+ * ambient adoption machinery stamped on its firewall. Activate it with
+ * initTransition; it is a plain batch until then. */
+export declare function createTransition(): Transition;
 export declare function currentTransition(transition: Transition): Transition;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;

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

@@ -365,17 +365,6 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
 export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
-/**
- * @deprecated `createEffect(compute)` (single argument) is no longer supported.
- * Pass a separate effect function as the second argument:
- * `createEffect(compute, effect)`. See [MISSING_EFFECT_FN].
- *
- * - For a side effect that reacts to changes, split the work:
- *   `createEffect(() => signal(), value => doWork(value))`.
- * - For a derived value, use `createMemo(() => signal())`.
- * - For a one-shot side effect at construction time, just call the function.
- */
-export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>): never;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.

package/dist/types-cjs/store/next/target.d.cts

@@ -34,6 +34,16 @@ export interface StoreNextFamily {
      * landing under an active override. Dead members prune lazily at each
      * landing (retainingTransition). */
     rt?: Set<any>;
+    /** Flight-owned transaction (#3146): declared when a truth-flight
+     * registers (the ask's transaction — created by the flight's own pending
+     * throw when none was ambient, the causing write's when one was), renewed
+     * per settle event once the previous reveal committed. Bare optimistic
+     * writes and landings route into it BY DECLARATION; the transitionBlocked
+     * store-half checks it for ownership instead of reconstructing it from
+     * `_optimisticStores` membership. null = no flight declared one (sync
+     * derive, or a loading-window flight — the loading rail is
+     * transaction-invisible, #2933). */
+    ft?: any;
     /** Normalized row-key fn (same resolution as the projection channels:
      * `options.key`, "id" default, null = unkeyed). The staged-landing walk
      * reads it: key-matched rows keep their proxy identity across a fold. */

package/package.json

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