@solidjs/signals 0.7.4 → 0.8.0

package/dist/types/boundaries.d.ts

@@ -1,21 +1,23 @@
-import { Computation, Queue } from "./core/index.js";
-import type { Effect } from "./core/index.js";
+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;
+}
 export declare class CollectionQueue extends Queue {
     _collectionType: number;
-    _nodes: Set<Effect>;
-    _disabled: Computation<boolean>;
+    _nodes: Set<Effect<any>>;
+    _disabled: Signal<boolean>;
     constructor(type: number);
     run(type: number): void;
-    notify(node: Effect, type: number, flags: number): boolean;
-    merge(queue: CollectionQueue): void;
+    notify(node: Effect<any>, type: number, flags: number): boolean;
 }
 export declare enum BoundaryMode {
     VISIBLE = "visible",
     HIDDEN = "hidden"
 }
 export declare function createBoundary<T>(fn: () => T, condition: () => BoundaryMode): () => T | undefined;
-export declare function createSuspense(fn: () => any, fallback: () => any): () => any;
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => any;
+export declare function createLoadBoundary(fn: () => any, fallback: () => any): () => unknown;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => unknown;
 export declare function flatten(children: any, options?: {
     skipNonRendered?: boolean;
     doNotUnwrap?: boolean;

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

@@ -1,14 +1,23 @@
-/**
- * See https://dev.to/modderme123/super-charging-fine-grained-reactive-performance-47ph
- * State clean corresponds to a node where all the sources are fully up to date
- * State check corresponds to a node where some sources (including grandparents) may have changed
- * State dirty corresponds to a node where the direct parents of a node has changed
- */
-export declare const STATE_CLEAN = 0;
-export declare const STATE_CHECK = 1;
-export declare const STATE_DIRTY = 2;
-export declare const STATE_DISPOSED = 3;
-export declare const EFFECT_PURE = 0;
-export declare const EFFECT_RENDER = 1;
-export declare const EFFECT_USER = 2;
+export declare const enum ReactiveFlags {
+    None = 0,
+    Check = 1,
+    Dirty = 2,
+    RecomputingDeps = 4,
+    InHeap = 8,
+    InHeapHeight = 16,
+    Zombie = 32,
+    Disposed = 64
+}
+export declare const enum StatusFlags {
+    None = 0,
+    Pending = 1,
+    Error = 2,
+    Uninitialized = 4
+}
+export declare const enum EffectType {
+    Pure = 0,
+    Render = 1,
+    User = 2
+}
+export declare const NOT_PENDING: {};
 export declare const SUPPORTS_PROXY: boolean;

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

@@ -0,0 +1,28 @@
+import { type Owner } from "./core.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>;
+/**
+ * Attempts to get a context value for the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ * @throws `ContextNotFoundError` if a context value has not been set yet.
+ */
+export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
+/**
+ * Attempts to set a context value on the parent scope with the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ */
+export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;

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

@@ -1,34 +1,15 @@
-/**
- * Nodes for constructing a graph of reactive values and reactive computations.
- *
- * - The graph is acyclic.
- * - The user inputs new values into the graph by calling .write() on one more computation nodes.
- * - The user retrieves computed results from the graph by calling .read() on one or more computation nodes.
- * - The library is responsible for running any necessary computations so that .read() is up to date
- *   with all prior .write() calls anywhere in the graph.
- * - We call the input nodes 'roots' and the output nodes 'leaves' of the graph here.
- * - Changes flow from roots to leaves. It would be effective but inefficient to immediately
- *   propagate all changes from a root through the graph to descendant leaves. Instead, we defer
- *   change most change propagation computation until a leaf is accessed. This allows us to
- *   coalesce computations and skip altogether recalculating unused sections of the graph.
- * - Each computation node tracks its sources and its observers (observers are other
- *   elements that have this node as a source). Source and observer links are updated automatically
- *   as observer computations re-evaluate and call get() on their sources.
- * - Each node stores a cache state (clean/check/dirty) to support the change propagation algorithm:
- *
- * In general, execution proceeds in three passes:
- *
- *  1. write() propagates changes down the graph to the leaves
- *     direct children are marked as dirty and their deeper descendants marked as check
- *     (no computations are evaluated)
- *  2. read() requests that parent nodes updateIfNecessary(), which proceeds recursively up the tree
- *     to decide whether the node is clean (parents unchanged) or dirty (parents changed)
- *  3. updateIfNecessary() evaluates the computation if the node is dirty (the computations are
- *     executed in root to leaf order)
- */
-import { type Flags } from "./flags.js";
-import { Owner } from "./owner.js";
-import { type Transition } from "./scheduler.js";
+import { NOT_PENDING, ReactiveFlags, StatusFlags } from "./constants.js";
+import { type IQueue, type Transition } from "./scheduler.js";
+export interface Disposable {
+    (): void;
+}
+export interface Link {
+    _dep: Signal<unknown> | Computed<unknown>;
+    _sub: Computed<unknown>;
+    _nextDep: Link | null;
+    _prevSub: Link | null;
+    _nextSub: Link | null;
+}
 export interface SignalOptions<T> {
     id?: string;
     name?: string;
@@ -36,125 +17,105 @@ export interface SignalOptions<T> {
     pureWrite?: boolean;
     unobserved?: () => void;
 }
-export interface SourceType {
-    _observers: ObserverType[] | null;
+export interface RawSignal<T> {
+    id?: string;
+    _subs: Link | null;
+    _subsTail: Link | null;
+    _value: T;
+    _error?: unknown;
+    _statusFlags: StatusFlags;
+    _name?: string;
+    _equals: false | ((a: T, b: T) => boolean);
+    _pureWrite?: boolean;
     _unobserved?: () => void;
-    _updateIfNecessary: () => void;
-    _stateFlags: Flags;
     _time: number;
+    _pendingValue: T | typeof NOT_PENDING;
+    _pendingCheck?: Signal<boolean> & {
+        _set: (v: boolean) => void;
+    };
+    _pendingSignal?: Signal<T> & {
+        _set: (v: T) => void;
+    };
     _transition?: Transition;
-    _cloned?: Computation;
 }
-export interface ObserverType {
-    _sources: SourceType[] | null;
-    _notify: (state: number, skipQueue?: boolean) => void;
-    _handlerMask: Flags;
-    _notifyFlags: (mask: Flags, newFlags: Flags) => void;
-    _time: number;
-    _cloned?: Computation;
+export interface FirewallSignal<T> extends RawSignal<T> {
+    _owner: Computed<any>;
+    _nextChild: FirewallSignal<unknown> | null;
 }
-/**
- * Returns the current observer.
- */
-export declare function getObserver(): Computation | null;
-export declare const UNCHANGED: unique symbol;
-export type UNCHANGED = typeof UNCHANGED;
-export declare class Computation<T = any> extends Owner implements SourceType, ObserverType {
-    _sources: SourceType[] | null;
-    _observers: ObserverType[] | null;
-    _value: T | undefined;
-    _error: unknown;
-    _compute: null | ((p?: T) => T);
-    _name: string | undefined;
-    _equals: false | ((a: T, b: T) => boolean);
-    _unobserved: (() => void) | undefined;
-    _pureWrite: boolean;
-    /** Whether the computation is an error or has ancestors that are unresolved */
-    _stateFlags: number;
-    /** Which flags raised by sources are handled, vs. being passed through. */
-    _handlerMask: number;
-    _time: number;
-    _forceNotify: boolean;
-    _transition?: Transition | undefined;
-    _cloned?: Computation;
-    _optimistic?: (() => void) & {
-        _transition?: Transition;
-        _init?: () => void;
-    };
-    constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
-    _read(): T;
-    /**
-     * Return the current value of this computation
-     * Automatically re-executes the surrounding computation when the value changes
-     */
-    read(): T;
-    /**
-     * Return the current value of this computation
-     * Automatically re-executes the surrounding computation when the value changes
-     *
-     * If the computation has any unresolved ancestors, this function waits for the value to resolve
-     * before continuing
-     */
-    wait(): T;
-    /** Update the computation with a new value. */
-    write(value: T | ((currentValue: T) => T) | UNCHANGED, flags?: number, raw?: boolean): T;
-    /**
-     * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
-     */
-    _notify(state: number, skipQueue?: boolean): void;
-    /**
-     * Notify the computation that one of its sources has changed flags.
-     *
-     * @param mask A bitmask for which flag(s) were changed.
-     * @param newFlags The source's new flags, masked to just the changed ones.
-     */
-    _notifyFlags(mask: Flags, newFlags: Flags): void;
-    _setError(error: unknown): void;
-    /**
-     * This is the core part of the reactivity system, which makes sure that the values are updated
-     * before they are read. We've also adapted it to return the loading state of the computation,
-     * so that we can propagate that to the computation's observers.
-     *
-     * This function will ensure that the value and states we read from the computation are up to date
-     */
-    _updateIfNecessary(): void;
-    /**
-     * Remove ourselves from the owner graph and the computation graph
-     */
-    _disposeNode(): void;
+export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
+export interface Owner {
+    id?: string;
+    _disposal: Disposable | Disposable[] | null;
+    _parent: Owner | null;
+    _context: Record<symbol | string, unknown>;
+    _childCount: number;
+    _queue: IQueue;
+    _firstChild: Owner | null;
+    _nextSibling: Owner | null;
+    _pendingDisposal: Disposable | Disposable[] | null;
+    _pendingFirstChild: Owner | null;
 }
-/**
- * Reruns a computation's _compute function, producing a new value and keeping track of dependencies.
- *
- * It handles the updating of sources and observers, disposal of previous executions,
- * and error handling if the _compute function throws. It also sets the node as loading
- * if it reads any parents that are currently loading.
- */
-export declare function update<T>(node: Computation<T>): void;
+export interface Computed<T> extends RawSignal<T>, Owner {
+    _deps: Link | null;
+    _depsTail: Link | null;
+    _flags: ReactiveFlags;
+    _height: number;
+    _nextHeap: Computed<any> | undefined;
+    _prevHeap: Computed<any>;
+    _fn: (prev?: T) => T;
+    _child: FirewallSignal<any> | null;
+    _notifyQueue?: (statusFlagsChanged: boolean, prevStatusFlags: number) => void;
+}
+export interface Root extends Owner {
+    _root: true;
+    _parentComputed: Computed<any> | null;
+    dispose(self?: boolean): void;
+}
+export declare function recompute(el: Computed<any>, create?: boolean): void;
+export declare function getNextChildId(owner: Owner): string;
+export declare function computed<T>(fn: (prev?: T) => T): Computed<T>;
+export declare function computed<T>(fn: (prev: T) => T, initialValue?: T, options?: SignalOptions<T>): Computed<T>;
+export declare function asyncComputed<T>(asyncFn: (prev?: T, refreshing?: boolean) => T | Promise<T> | AsyncIterable<T>): Computed<T> & {
+    _refresh: () => void;
+};
+export declare function asyncComputed<T>(asyncFn: (prev: T, refreshing?: boolean) => T | Promise<T> | AsyncIterable<T>, initialValue: T, options?: SignalOptions<T>): Computed<T> & {
+    _refresh: () => void;
+};
+export declare function signal<T>(v: T, options?: SignalOptions<T>): Signal<T>;
+export declare function signal<T>(v: T, options?: SignalOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /**
  * Returns the current value stored inside the given compute function without triggering any
  * dependencies. Use `untrack` if you want to also disable owner tracking.
  */
 export declare function untrack<T>(fn: () => T): T;
+export declare function read<T>(el: Signal<T> | Computed<T>): T;
+export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
+export declare function getObserver(): Owner | null;
+export declare function getOwner(): Owner | null;
+export declare function onCleanup(fn: Disposable): Disposable;
+export declare function createOwner(options?: {
+    id: string;
+}): Root;
 /**
- * Returns true if the given functinon contains signals that have been updated since the last time
- * the parent computation was run.
+ * Creates a new non-tracked reactive context with manual disposal
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @returns the output of `fn`.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
  */
-export declare function hasUpdated(fn: () => any): boolean;
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id: string;
+}): T;
 /**
- * Returns an accessor that is true if the given function contains async signals that are out of date.
+ * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
+ * This method untracks the current scope.
+ *
+ * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
  */
+export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
+export declare function staleValues<T>(fn: () => T, set?: boolean): T;
+export declare function pending<T>(fn: () => T): T;
 export declare function isPending(fn: () => any): boolean;
 export declare function isPending(fn: () => any, loadingValue: boolean): boolean;
-/**
- * Attempts to resolve value of expression synchronously returning the last resolved value for any async computation.
- */
-export declare function latest<T>(fn: () => T): T;
-export declare function latest<T, U>(fn: () => T, fallback: U): T | U;
-/**
- * A convenient wrapper that calls `compute` with the `owner` and `observer` and is guaranteed
- * to reset the global context after the computation is finished even if an error is thrown.
- */
-export declare function compute<T>(owner: Owner | null, fn: (val: T) => T, observer: Computation<T>): T;
-export declare function compute<T>(owner: Owner | null, fn: (val: undefined) => T, observer: null): T;

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

@@ -1,47 +1,19 @@
-import { EFFECT_RENDER, EFFECT_USER } from "./constants.js";
-import { Computation, type SignalOptions } from "./core.js";
-import { type Flags } from "./flags.js";
+import { type Computed, type Owner, type SignalOptions } from "./core.js";
+export interface Effect<T> extends Computed<T>, Owner {
+    _effectFn: (val: T, prev: T | undefined) => void | (() => void);
+    _errorFn?: (err: unknown, cleanup: () => void) => void;
+    _cleanup?: () => void;
+    _modified: boolean;
+    _prevValue: T | undefined;
+    _type: number;
+}
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
  */
-export declare class Effect<T = any> extends Computation<T> {
-    _effect: (val: T, prev: T | undefined) => void | (() => void);
-    _onerror: ((err: unknown, cleanup: () => void) => void) | undefined;
-    _cleanup: (() => void) | undefined;
-    _modified: boolean;
-    _prevValue: T | undefined;
-    _type: typeof EFFECT_RENDER | typeof EFFECT_USER;
-    constructor(initialValue: T, compute: (val?: T) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown) => void | (() => void), options?: SignalOptions<T> & {
-        render?: boolean;
-        defer?: boolean;
-    });
-    write(value: T, flags?: number): T;
-    _notify(state: number, skipQueue?: boolean): void;
-    _notifyFlags(mask: Flags, newFlags: Flags): void;
-    _setError(error: unknown): void;
-    _disposeNode(): void;
-    _run(type: number): void;
-}
-export declare class TrackedEffect extends Computation {
-    _type: number;
-    _cleanup: (() => void) | undefined;
-    constructor(compute: () => void | (() => void), options?: SignalOptions<undefined>);
-    _notify(state: number, skipQueue?: boolean): void;
-    _disposeNode(): void;
-    _run(type: number): void;
-}
-export declare class EagerComputation<T = any> extends Computation<T> {
-    constructor(initialValue: T, compute: () => T, options?: SignalOptions<T> & {
-        defer?: boolean;
-    });
-    _notify(state: number, skipQueue?: boolean): void;
-    _run(): void;
-}
-export declare class FirewallComputation extends Computation {
-    firewall: boolean;
-    constructor(compute: () => void);
-    _notify(state: number, skipQueue?: boolean): void;
-    _run(): void;
-}
+export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), initialValue?: T, options?: SignalOptions<any> & {
+    render?: boolean;
+    defer?: boolean;
+}): void;
+export declare function runEffect(this: Effect<any>): void;

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

@@ -1,5 +1,6 @@
 export declare class NotReadyError extends Error {
-    constructor(node: any);
+    cause: any;
+    constructor(cause: any);
 }
 export declare class NoOwnerError extends Error {
     constructor();

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

@@ -0,0 +1,15 @@
+import { ReactiveFlags } from "./constants.js";
+import type { Computed } from "./core.js";
+export interface Heap {
+    _heap: (Computed<unknown> | undefined)[];
+    _marked: boolean;
+    _min: number;
+    _max: number;
+}
+export declare function increaseHeapSize(n: number, heap: Heap): void;
+export declare function insertIntoHeap(n: Computed<any>, heap: Heap): void;
+export declare function insertIntoHeapHeight(n: Computed<unknown>, heap: Heap): void;
+export declare function deleteFromHeap(n: Computed<unknown>, heap: Heap): void;
+export declare function markHeap(heap: Heap): void;
+export declare function markNode(el: Computed<unknown>, newState?: ReactiveFlags): void;
+export declare function runHeap(heap: Heap, recompute: (el: Computed<unknown>) => void): void;

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

@@ -1,7 +1,6 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
-export { Owner, createContext, getContext, setContext, hasContext, getOwner, onCleanup, type Context, type ContextRecord, type Disposable } from "./owner.js";
-export { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, UNCHANGED, compute, type SignalOptions } from "./core.js";
-export { Effect, EagerComputation } from "./effect.js";
-export { flush, Queue, incrementClock, Transition, ActiveTransition, cloneGraph, type IQueue } from "./scheduler.js";
+export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
+export { getObserver, isEqual, untrack, getOwner, runWithOwner, createOwner, createRoot, computed, signal, asyncComputed, read, setSignal, onCleanup, getNextChildId, isPending, pending, staleValues, type Owner, type Computed, type Root, type Signal, type SignalOptions } from "./core.js";
+export { effect, type Effect } from "./effect.js";
+export { flush, Queue, type IQueue } from "./scheduler.js";
 export * from "./constants.js";
-export * from "./flags.js";

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

@@ -1,77 +1,51 @@
-import type { Computation, ObserverType, SourceType } from "./core.js";
-import type { Effect } from "./effect.js";
+import type { Computed, Signal } from "./core.js";
+import { type Heap } from "./heap.js";
 export declare let clock: number;
-export declare function incrementClock(): void;
-export declare let ActiveTransition: Transition | null;
-export declare let Unobserved: SourceType[];
+export declare let activeTransition: Transition | null;
+export declare let unobserved: Signal<unknown>[];
+export interface Transition {
+    time: number;
+    asyncNodes: Computed<any>[];
+    pendingNodes: Signal<any>[];
+    queues: [QueueCallback[], QueueCallback[]];
+}
+export declare function schedule(): void;
+export declare const dirtyQueue: Heap;
+export declare const zombieQueue: Heap;
 export type QueueCallback = (type: number) => void;
 export interface IQueue {
     enqueue(type: number, fn: QueueCallback): void;
     run(type: number): boolean | void;
-    flush(): void;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
     created: number;
-    notify(...args: any[]): boolean;
-    merge(queue: IQueue): void;
+    notify(node: Computed<any>, mask: number, flags: number): boolean;
     _parent: IQueue | null;
-    _cloned?: IQueue | undefined;
 }
 export declare class Queue implements IQueue {
     _parent: IQueue | null;
-    _running: boolean;
     _queues: [QueueCallback[], QueueCallback[]];
     _children: IQueue[];
     created: number;
-    enqueue(type: number, fn: QueueCallback): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    notify(node: Computed<any>, mask: number, flags: number): boolean;
     run(type: number): void;
+    enqueue(type: number, fn: QueueCallback): void;
+}
+export declare class GlobalQueue extends Queue {
+    _running: boolean;
+    _pendingNodes: Signal<any>[];
+    static _update: (el: Computed<unknown>) => void;
+    static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
     flush(): void;
-    addChild(child: IQueue): any;
-    removeChild(child: IQueue): any;
-    notify(...args: any[]): boolean;
-    merge(queue: Queue): void;
+    notify(node: Computed<any>, mask: number, flags: number): boolean;
+    initTransition(node: Computed<any>): void;
 }
-export declare const globalQueue: Queue;
+export declare const globalQueue: GlobalQueue;
 /**
  * By default, changes are batched on the microtask queue which is an async process. You can flush
  * the queue synchronously to get the latest updates by calling `flush()`.
  */
 export declare function flush(): void;
-export declare function removeSourceObservers(node: ObserverType, index: number): void;
-export declare class Transition implements IQueue {
-    _sources: Map<Computation, Computation>;
-    _pendingNodes: Set<Effect>;
-    _promises: Set<Promise<any>>;
-    _optimistic: Set<(() => void) & {
-        _transition?: Transition;
-    }>;
-    _done: Transition | boolean;
-    _queues: [QueueCallback[], QueueCallback[]];
-    _clonedQueues: Map<Queue, Queue>;
-    _pureQueue: QueueCallback[];
-    _children: IQueue[];
-    _parent: IQueue | null;
-    _running: boolean;
-    _scheduled: boolean;
-    _cloned: Queue;
-    _signal: Computation;
-    created: number;
-    constructor(signal: Computation);
-    enqueue(type: number, fn: QueueCallback): void;
-    run(type: number): void;
-    flush(): void;
-    addChild(child: IQueue): void;
-    removeChild(child: IQueue): void;
-    notify(node: Effect, type: number, flags: number): boolean;
-    merge(queue: Transition): void;
-    schedule(): void;
-    runTransition(fn: () => any | Promise<any>, force?: boolean): void;
-    addOptimistic(fn: (() => void) & {
-        _transition?: Transition;
-    }): void;
-}
-export declare function cloneGraph(node: Computation): Computation;
-export declare function getOGSource<T extends Computation>(input: T): T;
-export declare function getTransitionSource<T extends Computation>(input: T): T;
-export declare function getQueue(node: Computation): IQueue;
-export declare function initialDispose(node: any): void;
+export declare function transitionComplete(transition: Transition): boolean;

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
-export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flush, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, SUPPORTS_PROXY } from "./core/index.js";
-export type { SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
-export { mapArray, repeat, type Maybe } from "./map.js";
+export { ContextNotFoundError, NoOwnerError, NotReadyError, createContext, createRoot, runWithOwner, flush, getNextChildId, getContext, setContext, getOwner, onCleanup, getObserver, isEqual, untrack, isPending, pending, SUPPORTS_PROXY } from "./core/index.js";
+export type { Owner, SignalOptions, Context, ContextRecord, IQueue } from "./core/index.js";
 export * from "./signals.js";
+export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
-export { createSuspense, createErrorBoundary, createBoundary, flatten, type BoundaryMode } from "./boundaries.js";
+export { createLoadBoundary, createErrorBoundary, createBoundary, flatten, type BoundaryMode } from "./boundaries.js";

package/dist/types/map.d.ts

@@ -1,4 +1,4 @@
-import type { Accessor } from "./signals.js";
+import { type Accessor } from "./signals.js";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
  * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow