@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.8

package/dist/{types-cjs/core/constants.d.cts → observe/core/constants.js}

@@ -1,23 +1,35 @@
-export declare const REACTIVE_NONE = 0;
-export declare const REACTIVE_CHECK: number;
-export declare const REACTIVE_DIRTY: number;
-export declare const REACTIVE_RECOMPUTING_DEPS: number;
-export declare const REACTIVE_IN_HEAP: number;
-export declare const REACTIVE_IN_HEAP_HEIGHT: number;
-export declare const REACTIVE_ZOMBIE: number;
-export declare const REACTIVE_DISPOSED: number;
-export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
-export declare const REACTIVE_SNAPSHOT_STALE: number;
-export declare const REACTIVE_LAZY: number;
-export declare const REACTIVE_MANUAL_WRITE: number;
+const REACTIVE_NONE = 0;
+
+const REACTIVE_CHECK = 1 << 0;
+
+const REACTIVE_DIRTY = 1 << 1;
+
+const REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+
+const REACTIVE_IN_HEAP = 1 << 3;
+
+const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+
+const REACTIVE_ZOMBIE = 1 << 5;
+
+const REACTIVE_DISPOSED = 1 << 6;
+
+const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
+
+const REACTIVE_SNAPSHOT_STALE = 1 << 8;
+
+const REACTIVE_LAZY = 1 << 9;
+
+const REACTIVE_MANUAL_WRITE = 1 << 10;
+
 /**
  * The pending recompute is a re-ask of the same question: `refresh()` dirtied
  * the node while no tracked input changed value. Cleared whenever a real
  * value-change notification arrives (`insertSubs`), and consumed by
  * `recompute` into the node's `_reask` classification — a quiet (re-ask)
  * pending window does not read as pending (question-scoped pending model).
- */
-export declare const REACTIVE_REASK: number;
+ */ const REACTIVE_REASK = 1 << 11;
+
 /**
  * A dependency write landed while this subscriber was mid-recompute — a
  * nested pull committed beneath one of its reads (#3037). The heap refuses
@@ -25,32 +37,52 @@ export declare const REACTIVE_REASK: number;
  * values the pass read before the nested commit are stale. Only set for
  * links validated this pass (gen-current): a write to an untouched link is
  * either re-read later in the pass (fresh) or trimmed with it (not a dep).
- */
-export declare const REACTIVE_MISSED_WAKE: number;
-export declare const CONFIG_OWNED_WRITE: number;
-export declare const CONFIG_NO_SNAPSHOT: number;
-export declare const CONFIG_TRANSPARENT: number;
-export declare const CONFIG_IN_SNAPSHOT_SCOPE: number;
-export declare const CONFIG_CHILDREN_FORBIDDEN: number;
-export declare const CONFIG_AUTO_DISPOSE: number;
-export declare const CONFIG_SYNC: number;
-export declare const CONFIG_OPTIMISTIC: number;
-export declare const CONFIG_HAS_COMPANIONS: number;
-export declare const CONFIG_HAS_SNAPSHOT: number;
-export declare const CONFIG_HAS_LANE: number;
+ */ const REACTIVE_MISSED_WAKE = 1 << 12;
+
+// Static configuration bits packed into Owner/Computed/Signal _config.
+const CONFIG_OWNED_WRITE = 1 << 0;
+
+const CONFIG_NO_SNAPSHOT = 1 << 1;
+
+const CONFIG_TRANSPARENT = 1 << 2;
+
+const CONFIG_IN_SNAPSHOT_SCOPE = 1 << 3;
+
+const CONFIG_CHILDREN_FORBIDDEN = 1 << 4;
+
+const CONFIG_AUTO_DISPOSE = 1 << 5;
+
+const CONFIG_SYNC = 1 << 6;
+
+// Presence bits (stage-3 hot-path monomorphism, DESIGN-PATCH-CHANNEL §11b):
+// optional per-node slots (_overrideValue, _pendingSignal/_latestValueComputed,
+// _snapshotValue, _optimisticLane) are NOT part of every node's hidden class —
+// reading a missing property defeats V8's inline caches on the hottest write/
+// notify loops. These bits live on the always-present `_config` so hot paths
+// pay one monomorphic masked read and only touch the optional field when its
+// installer flagged it. Bits are STICKY ("may be set") — the guarded field
+// read remains authoritative.
+const CONFIG_OPTIMISTIC = 1 << 7;
+
+const CONFIG_HAS_COMPANIONS = 1 << 8;
+
+const CONFIG_HAS_SNAPSHOT = 1 << 9;
+
+const CONFIG_HAS_LANE = 1 << 10;
+
 /** Set on a FIREWALL computed when any of its child signals creates an
  * isPending()/latest() companion. Gates the post-recompute child-companion
  * walk (#3038): a store computed's `_child` chain holds one node per
  * materialized leaf, so walking it unconditionally makes every update cost
  * O(all leaves ever read). Sticky — set at companion creation, never
- * cleared; sync-only apps never set it and never pay the walk. */
-export declare const CONFIG_CHILD_COMPANIONS: number;
+ * cleared; sync-only apps never set it and never pay the walk. */ const CONFIG_CHILD_COMPANIONS = 1 << 11;
+
 /** Set on a computed when its first firewall child signal is installed
  * (projection machinery). Gates markNode's firewall-children walk with one
  * masked read of the always-present _config — the walk's old `_child` read
  * moved into the cold extension (§12), and an unconditional `_x` deref per
- * marked node measurably taxed the propagation hot path (diamond -22%). */
-export declare const CONFIG_FW_CHILDREN: number;
+ * marked node measurably taxed the propagation hot path (diamond -22%). */ const CONFIG_FW_CHILDREN = 1 << 12;
+
 /** Authoritative-view reader (`until()`): while this node computes, reads
  * dodge active optimistic OVERRIDES only — the predicate must observe
  * arriving truth, never the caller's own tentative writes (which would
@@ -61,24 +93,24 @@ export declare const CONFIG_FW_CHILDREN: number;
  * action issued lands staged and cannot commit until the hold releases).
  * read() checks the bit on the reading computation (`context`) directly — no
  * ambient flag — so a shared computed the predicate pulls recomputes as
- * itself (no bit) under the normal view, and its cache never forks. */
-export declare const CONFIG_AUTHORITATIVE_READ: number;
+ * itself (no bit) under the normal view, and its cache never forks. */ const CONFIG_AUTHORITATIVE_READ = 1 << 13;
+
 /** Sticky mark: an authoritative-view reader read this node PAST an active
  * override. The ack shape — an authoritative arrival EQUAL to the override —
  * rides paths that are deliberately silent under A17 (every ordinary reader
  * sees the override, so an equal landing changes nothing for them). A marked
  * node notifies those readers on such paths anyway, so the landed truth is
  * seen without re-firing ordinary subscribers. Never cleared — only nodes an
- * until() predicate observed mid-override pay. */
-export declare const CONFIG_AUTHORITATIVE_OBSERVED: number;
+ * until() predicate observed mid-override pay. */ const CONFIG_AUTHORITATIVE_OBSERVED = 1 << 14;
+
 /** Promise-delivery effect (resolve()/until()): commits its computed value
  * directly even when recomputing under its own held transition. These
  * effects deliver applies on a microtask (#2930) instead of the stashed
  * effect queues, so the value must ride the same immediate schedule — a
  * staged value with an immediate apply delivers stale state (resolve) or
  * deadlocks the hold (until). Safe because the node is a private leaf: no
- * subscriber reads an effect's value, only its own apply does. */
-export declare const CONFIG_DIRECT_COMMIT: number;
+ * subscriber reads an effect's value, only its own apply does. */ const CONFIG_DIRECT_COMMIT = 1 << 15;
+
 /** Fresh-pull reader (awaitable `refresh()`'s waiter effect): a read of a
  * dirty source recomputes it inline even when the height gate defers to the
  * flush. Closes the same-flush ordering race where a waiter created
@@ -87,8 +119,8 @@ export declare const CONFIG_DIRECT_COMMIT: number;
  * pending window (async — woken by the settle walk, which runs on every
  * landing including equal-value ones) or serves its sync answer. resolve()
  * deliberately keeps that race — its contract is "first settled value"
- * (#2930), not "next quiescent state". */
-export declare const CONFIG_FRESH_READ: number;
+ * (#2930), not "next quiescent state". */ const CONFIG_FRESH_READ = 1 << 16;
+
 /** HELD truth (#3164): this node's staged `_pendingValue` is confirming
  * truth riding a transaction that retains optimism, revealed only at that
  * transaction's settle. Two arming sites, one meaning: the store fold
@@ -103,26 +135,55 @@ export declare const CONFIG_FRESH_READ: number;
  * exemption that keeps holds deadlock-free. Override-covered nodes never
  * arm: the override is their display and its revert their notification
  * (A17). Cleared at commit (the commit IS the reveal); subscribers masked
- * during the hold are woken by finalizePureQueue's post-revert pass. */
-export declare const CONFIG_HELD_TRUTH: number;
+ * during the hold are woken by finalizePureQueue's post-revert pass. */ const CONFIG_HELD_TRUTH = 1 << 17;
+
 /** SLOT node (store leaf): created through `slotSignal` with `_host`/`_key`
  * backrefs baked into the literal. The unobserved sweep dispatches these to
  * the ONE shared hook (`setSlotUnobserved`) instead of a per-node closure
  * held in a per-node extension — store mounts materialize one signal per
  * touched leaf, so per-node allocations (options object, equals closure,
  * unobserved closure, NodeExtension) were the measured create-floor bytes
- * (warm dbmon profile: store node machinery ~36% + GC ~29%). */
-export declare const CONFIG_SLOT_NODE: number;
-export declare const STATUS_NONE = 0;
-export declare const STATUS_PENDING: number;
-export declare const STATUS_ERROR: number;
-export declare const STATUS_UNINITIALIZED: number;
-export declare const EFFECT_PURE = 0;
-export declare const EFFECT_RENDER = 1;
-export declare const EFFECT_USER = 2;
-export declare const EFFECT_TRACKED = 3;
-export declare const NOT_PENDING: {};
-export declare const NO_SNAPSHOT: {};
+ * (warm dbmon profile: store node machinery ~36% + GC ~29%). */ const CONFIG_SLOT_NODE = 1 << 18;
+
+/** Optimistic node whose own source arrived with a value DIFFERENT from its
+ * active override (A18 supersession, #3331). The override survives only as
+ * the displayed value — untracked reads and the applied frame keep it until
+ * the owning transaction commits — while the graph has already moved to the
+ * staged truth in `_pendingValue`: tracked readers see it and the corrected
+ * cascade is that transaction's held work. Set by the two own-source write
+ * paths (asyncWrite, transition-held recompute); cleared by a fresh optimistic
+ * write (a new override re-masks) and by the revert. */ const CONFIG_OVERRIDE_SUPERSEDED = 1 << 19;
+
+/** In-flight async node whose inputs were PUBLISHED while it was pending: a
+ * batch or transaction committed with the node still `STATUS_PENDING` (an
+ * unobserved flight, #3305), so the inputs are on screen and the node's
+ * committed `_value` is stale against them. Governs read()'s reveal
+ * carve-out: a stale (render) reader in some OTHER transaction may show a
+ * foreign-held pending node's committed value — parallel transactions, no
+ * entanglement — only while that value is coherent with the visible frame,
+ * i.e. while the flight's inputs are themselves held (unpublished) and not
+ * lane-revealed. Set by `commitPendingNodes`; cleared when the node next
+ * enters pending fresh (a new flight from a settled state). */ const CONFIG_INPUTS_PUBLISHED = 1 << 21;
+
+const STATUS_PENDING = 1 << 0;
+
+const STATUS_ERROR = 1 << 1;
+
+const STATUS_UNINITIALIZED = 1 << 2;
+
+const EFFECT_RENDER = 1;
+
+const EFFECT_USER = 2;
+
+const EFFECT_TRACKED = 3;
+
+/** OR-ed into the `type` a lane passes to its effect runners: lane runs
+ * apply ahead of their transaction and are exempt from ownership parking. */ const LANE_RUN = 4;
+
+const NOT_PENDING = {};
+
+const NO_SNAPSHOT = {};
+
 /**
  * Stand-in stored in `_overrideValue` for an optimistic write of literal
  * `undefined` (#2898). The slot doubles as the optimistic-node brand
@@ -131,29 +192,24 @@ export declare const NO_SNAPSHOT: {};
  * follow-up writes route off the optimistic path and commit permanently.
  * Same shape as NO_SNAPSHOT. Sites that surface the override VALUE unwrap
  * via `visibleOverrideValue`; slot identity tests stay raw.
- */
-export declare const OVERRIDE_UNDEFINED: {};
-/** Unwrap an active override's stored value for surfacing to readers (#2898). */
-export declare function unwrapOverride<T = any>(v: unknown): T;
-export declare const STORE_SNAPSHOT_PROPS = "sp";
-export declare const SUPPORTS_PROXY: boolean;
-export declare const defaultContext: {};
+ */ const OVERRIDE_UNDEFINED = {};
+
+/** Unwrap an active override's stored value for surfacing to readers (#2898). */ function unwrapOverride(E) {
+    return E === OVERRIDE_UNDEFINED ? undefined : E;
+}
+
+const STORE_SNAPSHOT_PROPS = "sp";
+
+const SUPPORTS_PROXY = typeof Proxy === "function";
+
+const defaultContext = {};
+
 /**
  * Brand symbol used by `Refreshable<T>` values (projection stores, async
  * memos) to expose their underlying computation to `refresh()`. Not part of
  * the user-facing API.
  *
  * @internal
- */
-export declare const $REFRESH: unique symbol;
-/**
- * Brand applied to values that participate in the `refresh()` re-run protocol.
- * Accessors receive this handle internally; projected stores expose it through
- * their public return type so user-defined hooks that wrap `createOptimisticStore`
- * / `createProjection` / projection-form `createStore` can have their return
- * types inferred without leaking the internal `$REFRESH` symbol into public type
- * signatures (TS4058).
- */
-export type Refreshable<T> = T & {
-    readonly [$REFRESH]: any;
-};
+ */ const $REFRESH = Symbol("refresh");
+
+export { $REFRESH, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_AUTHORITATIVE_READ, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_CHILD_COMPANIONS, CONFIG_DIRECT_COMMIT, CONFIG_FRESH_READ, CONFIG_FW_CHILDREN, CONFIG_HAS_COMPANIONS, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, CONFIG_HELD_TRUTH, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OPTIMISTIC, CONFIG_OVERRIDE_SUPERSEDED, CONFIG_OWNED_WRITE, CONFIG_SLOT_NODE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, LANE_RUN, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };

package/dist/{types-cjs/core/context.d.cts → observe/core/context.js}

@@ -1,9 +1,7 @@
-import type { Owner } from "./types.cjs";
-export interface Context<T> {
-    readonly id: symbol;
-    readonly defaultValue: T | undefined;
-}
-export type ContextRecord = Record<string | symbol, unknown>;
+import { NoOwnerError, ContextNotFoundError } from "./error.js";
+
+import { getOwner } from "./owner.js";
+
 /**
  * Context provides a form of dependency injection. It is used to save from needing to pass
  * data as props through intermediate components. This function creates a new context object
@@ -11,8 +9,13 @@ export type ContextRecord = Record<string | symbol, unknown>;
  *
  * A default value can be provided here which will be used when a specific value is not provided
  * via a `setContext` call.
- */
-export declare function createContext<T>(defaultValue?: T, description?: string): Context<T>;
+ */ function createContext(e, t) {
+    return {
+        id: Symbol(t),
+        defaultValue: e
+    };
+}
+
 /**
  * Low-level owner-targeted context read. The user-facing read API is
  * `useContext` (in `solid-js`), which wraps this primitive. Exposed here for
@@ -22,8 +25,19 @@ export declare function createContext<T>(defaultValue?: T, description?: string)
  * @throws `ContextNotFoundError` if a context value has not been set yet.
  *
  * @internal
- */
-export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
+ */ function getContext(e, t = getOwner()) {
+    if (!t) {
+        throw new NoOwnerError;
+    }
+    // `undefined` alone means unset — a provided `null` is a value (no `??`).
+        let r = t.ft[e.id];
+    if (r === undefined) r = e.defaultValue;
+    if (r === undefined) {
+        throw new ContextNotFoundError;
+    }
+    return r;
+}
+
 /**
  * Low-level owner-targeted context write. The user-facing API is
  * `createContext` (in `solid-js`); its provider component wraps this
@@ -32,5 +46,16 @@ export declare function getContext<T>(context: Context<T>, owner?: Owner | null)
  * @throws `NoOwnerError` if there's no owner at the time of call.
  *
  * @internal
- */
-export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;
+ */ function setContext(e, t, r = getOwner()) {
+    if (!r) {
+        throw new NoOwnerError;
+    }
+    // We're creating a new object to avoid child context values being exposed to parent owners. If
+    // we don't do this, everything will be a singleton and all hell will break lose.
+        r.ft = {
+        ...r.ft,
+        [e.id]: t === undefined ? e.defaultValue : t
+    };
+}
+
+export { createContext, getContext, setContext };