@solidjs/signals 2.0.0-beta.15 → 2.0.0-beta.16

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

@@ -10,6 +10,14 @@ export interface Link {
     _nextDep: Link | null;
     _prevSub: Link | null;
     _nextSub: Link | null;
+    /**
+     * `_sub._depGen` at the time this link was created or last revalidated
+     * in-order. A link stamped with the subscriber's current pass generation is
+     * inside the validated `[deps.._depsTail]` prefix — an O(1) replacement for
+     * scanning the dep list to answer membership (see `link()`).
+     */
+    _gen: number;
+    _pendingObserver?: boolean;
 }
 export interface NodeOptions<T> {
     id?: string;
@@ -50,6 +58,8 @@ export interface Owner {
     id?: string;
     _config: number;
     _snapshotScope?: boolean;
+    /** Effect-returned cleanup; managed across reruns, invoked at true disposal */
+    _cleanup?: () => void;
     _disposal: Disposable | Disposable[] | null;
     _parent: Owner | null;
     _context: Record<symbol | string, unknown>;
@@ -64,6 +74,8 @@ export interface Owner {
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
+    /** Recompute-pass counter; bumped when dep revalidation starts. */
+    _depGen: number;
     _flags: number;
     _blocked?: boolean;
     _pendingSource?: Computed<any>;
@@ -77,6 +89,13 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
     _child: FirewallSignal<any> | null;
     _notifyStatus?: (status?: number, error?: any) => void;
+    /**
+     * Store-wide optimistic mask (count of this firewall's store targets with
+     * live optimistic writes). Non-zero decrees the whole store settled for
+     * `isPending` — the store is the primitive the mask covers (A20 re-rule
+     * 2026-07-07c).
+     */
+    _optimisticMask?: number;
 }
 export interface Root extends Owner {
     _root: true;

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

@@ -1,4 +1,4 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource } from "./core/index.cjs";
+export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.cjs";
 import { type Dev } from "./core/index.cjs";
 export declare const DEV: Dev | undefined;
 export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.cjs";

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

@@ -69,6 +69,17 @@ export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Promi
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
 export type EffectBundle<Prev, Next extends Prev = Prev> = {
     effect: EffectFunction<Prev, Next>;
+    /**
+     * Intercepts compute-phase errors (thrown by the compute function or arriving
+     * from upstream sources). Effect-phase throws are NOT routed here — they are
+     * your own imperative code and escalate to the nearest error boundary.
+     *
+     * This is the error arm of the effect phase: it runs on the same queue and
+     * in the same imperative, writable scope as `effect` (signal writes are
+     * legal), receives the error the user code threw, and observes settled
+     * outcomes — an error that recovers before the effect phase runs the
+     * `effect` arm instead, and a held transition defers it like `effect`.
+     */
     error: (err: unknown, cleanup: () => void) => void;
 };
 /** Options shared by every effect primitive. */
@@ -245,7 +256,24 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * `createTrackedEffect` (with the tradeoffs noted there).
  *
  * Pass an `EffectBundle` (`{ effect, error }`) instead of a plain function to
- * intercept errors thrown from the compute or effect phases.
+ * intercept **compute-phase** errors — errors thrown by `compute` or arriving
+ * from upstream reactive sources (including async rejections), which your own
+ * code has no frame to `try/catch`. The `error` handler is the error arm of
+ * the effect phase: it runs on the same schedule and in the same imperative,
+ * writable scope as `effect` (setting error state via signals is fine), and
+ * only for *settled* errors — a transient error that recovers before the
+ * effect phase runs `effect` with the recovered value instead, and a held
+ * transition defers it exactly as it defers `effect`. Without an `error`
+ * handler a compute-phase error is logged and the effect simply skips that
+ * run — a non-render effect's reactivity failing does not crash the app.
+ * Rethrowing from `error` escalates it to the nearest error boundary
+ * (halting the system if none exists).
+ *
+ * The **effect phase is different**: it is your own imperative code, so handle
+ * failures with `try/catch` where they occur. An uncaught effect-phase throw
+ * is treated as an unhandled application error — caught by the nearest
+ * `createErrorBoundary`/`<Errored>`, and permanently halting the reactive
+ * system if there is none. It is *not* routed to the bundle's `error` handler.
  *
  * ```typescript
  * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
@@ -383,7 +411,9 @@ export declare function createReaction(effectFn: EffectFunction<undefined> | Eff
  * Awaits a reactive expression and returns its first fully-settled value as a
  * `Promise`. Pending async reads (`createMemo` returning a promise, etc.) are
  * waited on; once the expression returns synchronously without `NotReadyError`
- * the promise resolves with that value.
+ * the promise resolves with that value. If the expression settles with an
+ * error instead — including an async source that rejects — the promise
+ * rejects with it.
  *
  * Must be called *outside* a tracking scope — it doesn't subscribe, it just
  * resolves the current value once.
@@ -459,6 +489,13 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * `onCleanup` is **not** allowed inside the callback — return a cleanup
  * function instead. The returned cleanup runs on owner disposal.
  *
+ * A cleanup return is only honored when `onSettled` is called from an **owned**
+ * scope (e.g. a component body). When it fires out of band from an *unowned*
+ * scope — an event handler, a tracked effect, or another `onSettled` — there is
+ * no owner lifecycle to bind a cleanup to; returning one is a dev-mode error
+ * (and is dropped in production). Use the post-settle/event-handler forms below
+ * for one-shot work, and keep setup-with-teardown in an owned scope.
+ *
  * @example
  * ```tsx
  * // Component-level setup + teardown — replaces onMount + onCleanup.

package/dist/types-cjs/store/projection.d.cts

@@ -1,5 +1,5 @@
 import { type Computed, type Refreshable } from "../core/index.cjs";
-import { type ProjectionOptions, type Store } from "./store.cjs";
+import { type NoFn, type ProjectionOptions, type Store } from "./store.cjs";
 export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
     store: Refreshable<Store<T>>;
     node: Computed<void | T>;
@@ -47,7 +47,7 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
-export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Refreshable<Store<T>>;
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
 /**
  * Shared projection computed body used by both `createProjection` and the derived
  * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`

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

@@ -41,7 +41,7 @@ type DataNodes = Record<PropertyKey, DataNode>;
  * @internal
  */
 export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
-export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_MASKED = "m";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
@@ -54,6 +54,8 @@ export type StoreNode = {
     [STORE_LOOKUP]?: WeakMap<any, any>;
     [STORE_FIREWALL]?: Computed<any>;
     [STORE_OPTIMISTIC]?: boolean;
+    /** This target currently contributes to its firewall's store-wide mask. */
+    [STORE_MASKED]?: boolean;
     [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
 };
 export declare namespace SolidStore {
@@ -63,13 +65,38 @@ export declare namespace SolidStore {
 export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
 export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
 export declare const storeLookup: WeakMap<WeakKey, any>;
+export declare const symbolKeyedRecords: WeakSet<object>;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
+export declare function ownEnumerableKeys(o: object): (string | symbol)[];
+/**
+ * Single chokepoint for the store's layered value resolution: returns the
+ * override layer (optimistic first, then regular) that shadows `property`, or
+ * `undefined` when the base `STORE_VALUE` is authoritative. Every trap must
+ * resolve through this — hand-inlining the layer order is how the optimistic
+ * layer gets missed (#2850).
+ */
+export declare function getOverlayLayer(target: StoreNode, property: PropertyKey): Record<PropertyKey, any> | undefined;
+/**
+ * The value a store leaf's backing signal currently shows to readers: active
+ * override, else held pending value, else committed value.
+ */
+export declare function visibleNodeValue(node: DataNode): any;
 export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
 export declare function notifySelf(target: StoreNode): void;
 export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
 export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
+/**
+ * Store-wide mask bookkeeping (A20 re-rule 2026-07-07c): the store is the
+ * primitive, so an optimistic write decrees the WHOLE store settled for
+ * `isPending` — firewall, written leaves, untouched siblings, structural
+ * reads — for the lifetime of the override/transition. The firewall carries a
+ * count of masked targets (nested objects mask independently); companions of
+ * the firewall and its probed leaves are poked on 0↔1 transitions so an
+ * already-materialized verdict flips without waiting for another write.
+ */
+export declare function maskStoreTarget(target: StoreNode, on: boolean): void;
 export declare const storeTraps: ProxyHandler<StoreNode>;
 export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => T | void): void;
 /**

package/package.json

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

package/dist/types/src/boundaries.d.ts

@@ -1,173 +0,0 @@
-import { Queue, type Computed, type Effect } from "./core/index.js";
-import type { Signal } from "./core/index.js";
-export interface BoundaryComputed<T> extends Computed<T> {
-    _propagationMask: number;
-}
-type RevealSlot = CollectionQueue | RevealController;
-type BoolAccessor = () => boolean;
-export type RevealOrder = "sequential" | "together" | "natural";
-type OrderAccessor = () => RevealOrder;
-export declare class RevealController {
-    _orderAccessor: OrderAccessor;
-    _collapsedAccessor: BoolAccessor;
-    _slots: RevealSlot[];
-    _parentController?: RevealController;
-    _disabled: Signal<boolean>;
-    _collapsed: Signal<boolean>;
-    _ready: boolean;
-    _minimallyReady: boolean;
-    _evaluating: boolean;
-    constructor(order: OrderAccessor, collapsed: BoolAccessor);
-    _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
-    isReady(): boolean;
-    /**
-     * "Minimally ready" = this group has something visible to show under its own policy.
-     * Used by an enclosing `together` group to decide when it can release.
-     * - `together`: fully ready (atomic).
-     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
-     * - `natural`: any owned slot is minimally ready.
-     */
-    isMinimallyReady(): boolean;
-    register(slot: RevealSlot): void;
-    unregister(slot: RevealSlot): void;
-    evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
-}
-export declare class CollectionQueue extends Queue {
-    _collectionType: number;
-    _sources: Set<Computed<any>>;
-    _tree?: BoundaryComputed<any>;
-    _pending: boolean;
-    _disabled: Signal<boolean>;
-    _collapsed: Signal<boolean>;
-    _revealController?: RevealController;
-    _initialized: boolean;
-    _onFn: (() => any) | undefined;
-    _prevOn: any;
-    constructor(type: number);
-    run(type: number): void;
-    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    checkSources(): void;
-}
-/**
- * Lower-level primitive that backs the `<Loading>` flow control. Catches
- * pending async reads inside `fn` and renders `fallback` until they settle.
- *
- * App code should use `<Loading fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @param fn the tracked subtree
- * @param fallback the fallback shown while async reads in `fn` are unresolved
- * @param options `on` — accessor whose value scopes the boundary; when set,
- *   transitions caused by writes to other reactive sources are *not* caught
- *
- * @example
- * ```tsx
- * // Custom boundary component built on top of the primitive.
- * function MyLoading(props: { fallback: JSX.Element; children: JSX.Element }) {
- *   return createLoadingBoundary(
- *     () => props.children,
- *     () => props.fallback
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
-    on?: () => any;
-}): import("./signals.js").SourceAccessor<unknown>;
-/**
- * Lower-level primitive that backs the `<Errored>` flow control. Catches
- * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
- * `reset()` recomputes the failing sources so the boundary can attempt to
- * recover.
- *
- * App code should use `<Errored fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @example
- * ```tsx
- * // Custom boundary that wraps the primitive and adds telemetry.
- * function TracedErrored(props: { fallback: (e: unknown) => JSX.Element; children: JSX.Element }) {
- *   return createErrorBoundary(
- *     () => props.children,
- *     (err, reset) => {
- *       reportError(err);
- *       return props.fallback(err);
- *     }
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.js").SourceAccessor<unknown>;
-/**
- * Coordinate the reveal timing of sibling loading boundaries.
- *
- * Accepts reactive accessors:
- * - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
- *   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
- *     as each resolves; later siblings stay hidden until earlier ones complete.
- *   - `"together"` — every direct slot stays on its fallback until the whole group
- *     is "minimally ready" (each direct slot has produced its own first visible
- *     content under its own order), then the whole group releases at once.
- *   - `"natural"` — children reveal independently (as each resolves). At the top
- *     level this is a no-op compared to not using `createRevealOrder`; the mode
- *     exists for nesting, where the group registers as a single composite slot to
- *     any enclosing `createRevealOrder`.
- * - `collapsed`: only meaningful when `order === "sequential"`. When set, tail siblings
- *   past the frontier suppress their own fallback output. Ignored under `"together"`
- *   and `"natural"` — those orders have no frontier.
- *
- * Nested `createRevealOrder` groups compose: the inner controller registers as a
- * single slot in the outer controller and is held on its fallbacks until the outer
- * releases that slot. Once released, the inner controller runs its own order locally
- * over anything still pending. There is no opt-out from an outer hold.
- *
- * "Minimally ready" is what an order considers its first visible content:
- * - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
- *   own minimal signal).
- * - `together` — every direct slot is minimally ready.
- * - `natural` — any direct slot has visible content (leaves on resolve; nested
- *   composites when fully ready, since natural treats composites as atomic).
- *
- * @example
- * ```ts
- * // Primitive form of `<Reveal>` — coordinate sibling loading boundaries
- * // programmatically. App code uses the JSX `<Reveal>` component instead.
- * // Both options are accessors so they can react to state changes.
- * createRevealOrder(
- *   () => renderSiblings(),
- *   { order: () => mode(), collapsed: () => true }
- * );
- * ```
- */
-export declare function createRevealOrder<T>(fn: () => T, options?: {
-    order?: OrderAccessor;
-    collapsed?: BoolAccessor;
-}): T;
-/**
- * Resolves a children value to its renderable form: unwraps zero-arg functions
- * (accessors), recursively flattens arrays, and optionally skips
- * non-rendering values (`null`, `undefined`, `true`, `false`, `""`).
- *
- * Used internally by flow components and by the renderer to walk a children
- * tree. App code rarely needs this directly — see `children()` in `solid-js`
- * for the user-facing helper that memoizes the result.
- *
- * @param children value or array of values to flatten
- * @param options
- *   - `skipNonRendered` — drop values that won't render
- *   - `doNotUnwrap` — leave function children as-is (caller will resolve)
- *
- * @example
- * ```ts
- * // Custom renderer walking a children tree manually. Most authors should
- * // use `children()` from solid-js, which memoizes the resolved value.
- * function renderChildren(value: unknown): unknown {
- *   return flatten(value, { skipNonRendered: true });
- * }
- * ```
- */
-export declare function flatten(children: any, options?: {
-    skipNonRendered?: boolean;
-    doNotUnwrap?: boolean;
-}): any;
-export {};

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

@@ -1,35 +0,0 @@
-/**
- * Wraps a generator function so each invocation runs as a single transaction
- * (a "transition") that batches every signal/store write between yields. The
- * surrounding UI sees one atomic update per yielded step; nothing is committed
- * until the action either completes or the next `yield` resolves.
- *
- * Yield promises (or any awaitable) inside the generator — the action waits
- * for each before continuing, but the writes you made beforehand are already
- * visible (or held by `<Loading>` if optimistic). Yield bare values for
- * synchronous batched steps.
- *
- * Each call returns a `Promise` that resolves with the generator's return
- * value, or rejects if it throws. Pair with `createOptimistic` /
- * `createOptimisticStore` to apply tentative writes that auto-revert if the
- * action fails.
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
- *
- * const addTodo = action(function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = yield api.createTodo(text); // network round-trip
- *   setTodos(t => {
- *     const i = t.findIndex(x => x.id === tempId);
- *     if (i >= 0) t[i] = saved;
- *   });
- *   return saved;
- * });
- *
- * await addTodo("buy milk");
- * ```
- */
-export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;

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

@@ -1,6 +0,0 @@
-import { type OptimisticLane } from "./lanes.js";
-import type { Computed } from "./types.js";
-export declare function settlePendingSource(el: Computed<any>): void;
-export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => 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, lane?: OptimisticLane): void;

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

@@ -1,51 +0,0 @@
-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;
-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 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: {};
-export declare const STORE_SNAPSHOT_PROPS = "sp";
-export declare const SUPPORTS_PROXY: boolean;
-export declare 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;
-};

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

@@ -1,36 +0,0 @@
-import type { Owner } from "./types.js";
-export interface Context<T> {
-    readonly id: symbol;
-    readonly defaultValue: T | undefined;
-}
-export type ContextRecord = Record<string | symbol, unknown>;
-/**
- * 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
- * that can be used with `getContext` and `setContext`.
- *
- * 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>;
-/**
- * Low-level owner-targeted context read. The user-facing read API is
- * `useContext` (in `solid-js`), which wraps this primitive. Exposed here for
- * cross-package wiring (e.g. hydration-aware context plumbing).
- *
- * @throws `NoOwnerError` if there's no owner at the time of call.
- * @throws `ContextNotFoundError` if a context value has not been set yet.
- *
- * @internal
- */
-export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
-/**
- * Low-level owner-targeted context write. The user-facing API is
- * `createContext` (in `solid-js`); its provider component wraps this
- * primitive. Exposed here for cross-package wiring.
- *
- * @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;