@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.11

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

@@ -1,45 +0,0 @@
-import { type Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "./store.js";
-/**
- * The store equivalent of `createOptimistic`. Writes inside an `action`
- * transition are tentative — they show up immediately but auto-revert (or
- * reconcile to the action's resolved value) once the transition finishes.
- *
- * Use this for optimistic UI on collection-shaped data. For single-value
- * optimistic state, prefer `createOptimistic`.
- *
- * - Plain form: `createOptimisticStore(initialValue)`.
- * - Derived form: `createOptimisticStore(fn, seed, options?)` — a projection
- *   store whose authoritative value is recomputed by `fn` and whose
- *   optimistic overlay reverts after each transition.
- *
- * `options.key` defaults to `"id"`; specify it only when your data uses a
- * different identity field (e.g. `{ key: "uuid" }` or `{ key: t => t.slug }`),
- * or `null` to merge positionally. Restating the default just adds noise.
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
- *
- * // Mutation: optimistic add, then in-place reconcile to the saved row.
- * const addTodo = action(function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); });
- *   const saved = yield api.createTodo(text);
- *   setTodos(t => {
- *     const i = t.findIndex(x => x.id === tempId);
- *     if (i >= 0) t[i] = saved;
- *   });
- * });
- *
- * // Return form: filter is the natural shape for removal.
- * const removeTodo = action(function* (id: string) {
- *   setTodos(t => t.filter(x => x.id !== id));
- *   yield api.removeTodo(id);
- * });
- * ```
- *
- * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
- */
-export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];

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

@@ -1,70 +0,0 @@
-import { type Computed, type Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store } from "./store.js";
-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>;
-};
-/**
- * Creates a derived (projected) store. Like `createMemo` but for stores: the
- * derive function receives a mutable draft and either mutates it in place
- * (canonical) or returns a new value. Either way the result is reconciled
- * against the previous draft by `options.key` (default `"id"`), so surviving
- * items keep their proxy identity — only added/removed items are
- * created/disposed.
- *
- * If the derive returns a different entity than the one currently held (the
- * `/users/1` → `/users/2` shape), the store swaps to it rather than merging,
- * and nothing below it is treated as surviving.
- *
- * Returns the projected store directly (no setter — reads only).
- *
- * Use this when you want the structural-sharing / per-property tracking
- * behaviour of a store on top of a derived computation. For simple read-only
- * derivations, `createMemo` is lighter.
- *
- * @param fn receives the current draft; mutate it in place or return new
- *   data. Return is convenient for filter/derive shapes where mutation is
- *   awkward.
- * @param seed the backing store value to wrap and reconcile into
- * @param options `ProjectionOptions` — `name`, `key`. `key` defaults to
- *   `"id"`; specify it only when your data uses a different identity field
- *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`), or `null` to merge
- *   positionally with no keyed pass.
- *
- * @example
- * ```ts
- * // Mutation form — update individual fields on the draft.
- * const summary = createProjection<{ total: number; active: number }>(
- *   draft => {
- *     draft.total = users().length;
- *     draft.active = users().filter(u => u.active).length;
- *   },
- *   { total: 0, active: 0 }
- * );
- *
- * // Return form — produce a derived collection. Reconciled by `id` so each
- * // surviving user keeps the same store identity across recomputes.
- * const activeUsers = createProjection<User[]>(
- *   () => allUsers().filter(u => u.active),
- *   []
- * );
- * ```
- *
- * @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> | 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`
- * wrapping, the `handleAsync` subscription with a setter callback, and the commit
- * path (which must always go through `storeSetter` so the `writeOnly` guard is
- * engaged during `reconcile`'s property reads).
- *
- * `wrapCommit` is invoked for every commit (sync return and each async yield) and
- * lets callers layer extra context around the write — e.g. the optimistic store
- * re-enters `setProjectionWriteActive` so reconciles target `STORE_OVERRIDE`
- * instead of `STORE_OPTIMISTIC_OVERRIDE` even when an async yield fires outside
- * the outer `setProjectionWriteActive` scope.
- */
-export declare function runProjectionComputed<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;
-export declare function createWriteTraps(isActive?: () => boolean, onDraftWrite?: () => void): ProxyHandler<any>;

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

@@ -1,46 +0,0 @@
-/**
- * Shared body of `reconcile()` and the projection commit. `replace` is the
- * only difference: a projection commit is a value swap, not a merge — its root
- * proxy is a cell handed out by `createProjection` that can never change
- * reference, so a derive returning a different entity is not the slot mistake
- * `reconcile()` throws on. Nothing below the root survives that swap, which is
- * the rule the keyed diff already applies at a nested slot on a key mismatch.
- *
- * @internal
- */
-export declare function reconcileState(value: any, state: any, key: any, replace: boolean): void;
-/**
- * Returns a draft-mutating function that smart-merges `value` into a store,
- * preserving fine-grained reactivity: only changed leaves trigger updates.
- *
- * With a `key` (default `"id"`), array items whose key matches between old
- * and new states keep their identity (updated in place, moves and removals
- * update the corresponding signals) — the shape for keyed server payloads.
- * Items without the key field fall back to positional matching.
- *
- * With `key: null`, matching is purely positional: index N of the new array
- * merges into index N of the old, and object properties merge recursively —
- * the classic pattern for fixed-shape data that churns in place (dashboards,
- * monitors), where no keyed diff pass is needed or wanted.
- *
- * Merging into a slot that holds a *different* entity throws — the caller
- * picked the slot, so a key mismatch there is a bug.
- *
- * @param value the next state to merge in
- * @param key property name (string) or extractor function for stable
- * identity (default `"id"`); pass `null` for positional merging
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createStore<Todo[]>([]);
- *
- * async function refresh() {
- *   const fresh = await api.getTodos();
- *   setTodos(reconcile(fresh)); // diff-merge by `id`
- * }
- *
- * // fixed-shape polling data — positional merge
- * setStats(reconcile(nextStats, null));
- * ```
- */
-export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => void;

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

@@ -1,47 +0,0 @@
-import type { Accessor } from "./signals.cjs";
-import { type Store } from "./store/store.cjs";
-/**
- * Declares that in-flight work will change the targeted data: the named
- * slot(s) — and everything DERIVED from them — read as pending
- * (`isPending` → `true`) from the declaration until the surrounding
- * transaction settles or reverts. A mark lives on its own channel — a
- * refcount on the marked node plus dep-graph reachability in the verdict
- * layer — so the marked values themselves stay readable (a mark is a promise
- * of change, not an absence of value), no reader ever suspends on one, and
- * completion/settlement accounting never sees one. This is the declaration
- * verb of the pending model — additive only. A mark can turn pending ON for
- * data the graph can't see changing yet; nothing can turn pending OFF while
- * a real change is in flight — a quiet `refresh()` re-ask under a mark still
- * reads pending (declaring the reload is what makes it a real question).
- *
- * Targets:
- * - `affects(store)` — a store proxy (any record, root or nested): every
- *   record reachable from it at declaration time reads pending, including
- *   through captured child proxies (e.g. `<For>` rows). Siblings are
- *   untouched; records added after the declaration are not covered.
- * - `affects(record, key)` — exactly the named slot of the record. One key
- *   per call (keys do NOT form a path — target the owning record directly).
- * - `affects(accessor)` — a source accessor (signal or memo): the source
- *   reads pending.
- *
- * Typically called at the top of an `action` alongside optimistic writes —
- * both are up-front declarations about the same mutation. Outside any
- * transaction the mark is released at the end of the current flush.
- *
- * @example
- * ```ts
- * const send = action(function* (text: string) {
- *   setState(s => { s.messages.push({ text, status: "sending" }); });
- *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
- *   yield api.send(text);
- * });
- *
- * const reload = action(function* () {
- *   affects(thing);      // the whole store pends…
- *   refresh(thing);      // …over this otherwise-quiet re-ask
- *   yield api.done();
- * });
- * ```
- */
-export declare function affects(target: Accessor<unknown> | Store<object>): void;
-export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;

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

@@ -1,175 +0,0 @@
-import { Queue, type Computed, type Effect } from "./core/index.cjs";
-import type { Signal } from "./core/index.cjs";
-import { type Accessor } from "./signals.cjs";
-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`: every direct slot is minimally ready.
-     * - `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>;
-    _error?: Signal<unknown>;
-    _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<T, U>(fn: () => T, fallback: () => U, options?: {
-    on?: () => any;
-}): Accessor<T | U>;
-/**
- * Lower-level primitive that backs the `<Errored>` flow control. Catches
- * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
- * `error` is an accessor for the latest captured error; `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<T, U>(fn: () => T, fallback: (error: Accessor<unknown>, reset: () => void) => U): Accessor<T | U>;
-/**
- * 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 via their own minimal signal).
- *
- * @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-cjs/core/action.d.cts

@@ -1,64 +0,0 @@
-/**
- * The primitive for mutations: imperative async workflows whose *writes span
- * an async gap* — optimistic write, server round-trip, reconciling write —
- * where intermediate state must not leak and failure must revert cleanly
- * (pair with `createOptimistic` / `createOptimisticStore`).
- *
- * Navigation-shaped updates do not need an action. A plain setter call is
- * enough: reads pull the async, and downstream async computeds hold their
- * previous values per-node until the new ones are ready (`isPending` /
- * `latest` expose the in-flight state). Reach for `action` only when writes
- * happen *after* async work, not merely upstream of it.
- *
- * Framework-level actions (router form actions, server actions) are
- * specializations of this primitive: they are actions in exactly this sense —
- * the same transactional semantics — with form binding, serialization, and
- * submission tracking layered on top. The shared name is deliberate.
- *
- * 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` is the transaction-safe suspension point: the action waits for a
- * yielded promise and re-enters the transaction before running the code after
- * it. A plain `await` does NOT — the runtime has no hook into an async
- * generator's internal await continuations, so writes to fresh signals
- * between an `await` and the next `yield` escape the transaction and commit
- * immediately. `await` is still the ergonomic choice for typed results; just
- * put a bare `yield` before any writes that follow it:
- *
- * ```ts
- * const saved = await api.createTodo(text); // typed result
- * yield; // re-enter the transaction before writing
- * setTodos(t => { ... });
- * ```
- *
- * (For the same reason, don't call `flush()` inside an action body — it
- * drains the transaction mid-step.)
- *
- * 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(async function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = await api.createTodo(text); // network round-trip, typed
- *   yield; // re-enter the transaction
- *   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-cjs/core/async.d.cts

@@ -1,21 +0,0 @@
-import { NotReadyError } from "./error.cjs";
-import { type OptimisticLane } from "./lanes.cjs";
-import type { Computed, Link } from "./types.cjs";
-export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
-/**
- * A loading-window node hit an unready source (sync throw in recompute, or a
- * NotReadyError-rejected flight): register for the source's settle — the
- * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
- * with NO read-visible pending status, no downstream propagation, no
- * transition, no lane registration. Commit #0 keeps serving.
- */
-export declare function parkLoadingWindow(el: Computed<any>, e: NotReadyError): void;
-export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
-export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
-export declare function releaseSettledDependents(el: Computed<any>): void;
-export declare function settleErroredDependents(el: Computed<any>, error: any): void;
-export declare function settlePendingSource(el: Computed<any>): void;
-export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
-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-cjs/core/constants.d.cts

@@ -1,71 +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;
-/**
- * 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;
-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: {};
-/**
- * Stand-in stored in `_overrideValue` for an optimistic write of literal
- * `undefined` (#2898). The slot doubles as the optimistic-node brand
- * (`undefined` = not optimistic, `NOT_PENDING` = at rest), so the raw value
- * would erase the node's optimistic identity: the write turns invisible and
- * 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: {};
-/**
- * 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;
-};