@solidjs/signals 0.0.1

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

@@ -0,0 +1,14 @@
+/**
+ * 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 SUPPORTS_PROXY: boolean;

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

@@ -0,0 +1,157 @@
+/**
+ * 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";
+export interface SignalOptions<T> {
+    name?: string;
+    equals?: ((prev: T, next: T) => boolean) | false;
+    unobserved?: () => void;
+}
+interface SourceType {
+    _observers: ObserverType[] | null;
+    _unobserved?: () => void;
+    _updateIfNecessary: () => void;
+    _stateFlags: Flags;
+    _time: number;
+}
+interface ObserverType {
+    _sources: SourceType[] | null;
+    _notify: (state: number) => void;
+    _handlerMask: Flags;
+    _notifyFlags: (mask: Flags, newFlags: Flags) => void;
+    _time: number;
+}
+/**
+ * Returns the current observer.
+ */
+export declare function getObserver(): ObserverType | null;
+export declare function incrementClock(): void;
+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;
+    _compute: null | ((p?: T) => T);
+    _name: string | undefined;
+    _equals: false | ((a: T, b: T) => boolean);
+    _unobserved: (() => void) | undefined;
+    /** 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;
+    _error: Computation<boolean> | null;
+    _loading: Computation<boolean> | null;
+    _time: number;
+    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;
+    /**
+     * Return true if the computation is the value is dependent on an unresolved promise
+     * Triggers re-execution of the computation when the loading state changes
+     *
+     * This is useful especially when effects want to re-execute when a computation's
+     * loading state changes
+     */
+    loading(): boolean;
+    /**
+     * Return true if the computation is the computation threw an error
+     * Triggers re-execution of the computation when the error state changes
+     */
+    error(): boolean;
+    /** 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): 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;
+}
+/**
+ * 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 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;
+/**
+ * Returns true if the given functinon contains signals that have been updated since the last time
+ * the parent computation was run.
+ */
+export declare function hasUpdated(fn: () => any): boolean;
+/**
+ * Returns true if the given function contains async signals that are not ready yet.
+ */
+export declare function isPending(fn: () => any): boolean;
+export declare function latest<T>(fn: () => T): T | undefined;
+/**
+ * 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, compute: (val: T) => T, observer: Computation<T>): T;
+export declare function compute<T>(owner: Owner | null, compute: (val: undefined) => T, observer: null): T;
+export {};

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

@@ -0,0 +1,27 @@
+import { EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+import { Computation, type SignalOptions } from "./core.js";
+import { type IQueue } from "./scheduler.js";
+/**
+ * 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;
+    _modified: boolean;
+    _prevValue: T | undefined;
+    _type: typeof EFFECT_RENDER | typeof EFFECT_USER;
+    _queue: IQueue;
+    constructor(initialValue: T, compute: () => T, effect: (val: T, prev: T | undefined) => void, options?: SignalOptions<T> & {
+        render?: boolean;
+    });
+    write(value: T, flags?: number): T;
+    _notify(state: number): void;
+    _setError(error: unknown): void;
+    _disposeNode(): void;
+}
+export declare class EagerComputation<T = any> extends Computation<T> {
+    _queue: IQueue;
+    constructor(initialValue: T, compute: () => T, options?: SignalOptions<T>);
+    _notify(state: number): void;
+}

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

@@ -0,0 +1,11 @@
+export declare class NotReadyError extends Error {
+}
+export declare class NoOwnerError extends Error {
+    constructor();
+}
+export declare class ContextNotFoundError extends Error {
+    constructor();
+}
+export interface ErrorHandler {
+    (error: unknown): void;
+}

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

@@ -0,0 +1,8 @@
+export type Flags = number;
+export declare const ERROR_OFFSET = 0;
+export declare const ERROR_BIT: number;
+export declare const ERROR: unique symbol;
+export declare const LOADING_OFFSET = 1;
+export declare const LOADING_BIT: number;
+export declare const LOADING: unique symbol;
+export declare const DEFAULT_FLAGS: number;

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

@@ -0,0 +1,7 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError, type ErrorHandler } 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 { flushSync, createBoundary, type IQueue, Queue } from "./scheduler.js";
+export { createSuspense } from "./suspense.js";
+export * from "./flags.js";

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

@@ -0,0 +1,90 @@
+/**
+ * Owner tracking is used to enable nested tracking scopes with automatic cleanup.
+ * We also use owners to also keep track of which error handling context we are in.
+ *
+ * If you write the following
+ *
+ *   const a = createOwner(() => {
+ *     const b = createOwner(() => {});
+ *
+ *     const c = createOwner(() => {
+ *       const d = createOwner(() => {});
+ *     });
+ *
+ *     const e = createOwner(() => {});
+ *   });
+ *
+ * The owner tree will look like this:
+ *
+ *    a
+ *   /|\
+ *  b-c-e
+ *    |
+ *    d
+ *
+ * Following the _nextSibling pointers of each owner will first give you its children, and then its siblings (in reverse).
+ * a -> e -> c -> d -> b
+ *
+ * Note that the owner tree is largely orthogonal to the reactivity tree, and is much closer to the component tree.
+ */
+import { type ErrorHandler } from "./error.js";
+import type { IQueue } from "./scheduler.js";
+export type ContextRecord = Record<string | symbol, unknown>;
+export interface Disposable {
+    (): void;
+}
+/**
+ * Returns the currently executing parent owner.
+ */
+export declare function getOwner(): Owner | null;
+export declare function setOwner(owner: Owner | null): Owner | null;
+export declare class Owner {
+    _parent: Owner | null;
+    _nextSibling: Owner | null;
+    _prevSibling: Owner | null;
+    _state: number;
+    _disposal: Disposable | Disposable[] | null;
+    _context: ContextRecord;
+    _handlers: ErrorHandler[] | null;
+    _queue: IQueue | null;
+    constructor(signal?: boolean);
+    append(child: Owner): void;
+    dispose(this: Owner, self?: boolean): void;
+    _disposeNode(): void;
+    emptyDisposal(): void;
+    handleError(error: unknown): void;
+}
+export interface Context<T> {
+    readonly id: symbol;
+    readonly defaultValue: T | undefined;
+}
+/**
+ * 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;
+/**
+ * Whether the given context is currently defined.
+ */
+export declare function hasContext(context: Context<any>, owner?: Owner | null): boolean;
+/**
+ * Runs the given function when the parent owner computation is being disposed.
+ */
+export declare function onCleanup(disposable: Disposable): void;

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

@@ -0,0 +1,26 @@
+import { Computation } from "./core.js";
+import type { Effect } from "./effect.js";
+export interface IQueue {
+    enqueue<T extends Computation | Effect>(type: number, node: T): void;
+    run(type: number): void;
+    flush(): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+}
+export declare class Queue implements IQueue {
+    _running: boolean;
+    _queues: [Computation[], Effect[], Effect[]];
+    _children: IQueue[];
+    enqueue<T extends Computation | Effect>(type: number, node: T): void;
+    run(type: number): void;
+    flush(): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+}
+export declare const globalQueue: Queue;
+/**
+ * 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 `flushSync()`.
+ */
+export declare function flushSync(): void;
+export declare function createBoundary<T>(fn: () => T, queue: IQueue): T;

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

@@ -0,0 +1,11 @@
+import { Computation } from "./core.js";
+import type { Effect } from "./effect.js";
+import { Queue } from "./scheduler.js";
+export declare class SuspenseQueue extends Queue {
+    _nodes: Set<Effect>;
+    _fallback: boolean;
+    _signal: Computation<boolean>;
+    run(type: number): void;
+    _update(node: Effect): void;
+}
+export declare function createSuspense(fn: () => any, fallbackFn: () => any): () => any;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flushSync, createBoundary, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, createSuspense } from "./core/index.js";
+export type { ErrorHandler, SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
+export { mapArray, type Maybe } from "./map.js";
+export * from "./signals.js";
+export * from "./store/index.js";

package/dist/types/map.d.ts

@@ -0,0 +1,12 @@
+import type { Accessor } from "./signals.js";
+export type Maybe<T> = T | void | null | undefined | false;
+/**
+ * Reactive map helper that caches each list item by reference to reduce unnecessary mapping on
+ * updates.
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#maparray}
+ */
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: boolean | ((item: Item) => any);
+    name?: string;
+}): Accessor<MappedItem[]>;

package/dist/types/signals.d.ts

@@ -0,0 +1,56 @@
+import type { SignalOptions } from "./core/index.js";
+import { Owner } from "./core/index.js";
+export interface Accessor<T> {
+    (): T;
+}
+export interface Setter<T> {
+    (value: T | SetValue<T>): T;
+}
+export interface SetValue<T> {
+    (currentValue: T): T;
+}
+export type Signal<T> = [read: Accessor<T>, write: Setter<T>];
+/**
+ * Wraps the given value into a signal. The signal will return the current value when invoked
+ * `fn()`, and provide a simple write API via `write()`. The value can now be observed
+ * when used inside other computations created with `computed` and `effect`.
+ */
+export declare function createSignal<T>(initialValue: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+export declare function createSignal<T>(fn: (prev?: T) => T, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
+export declare function createAsync<T>(fn: (prev?: T) => Promise<T> | AsyncIterable<T> | T, initial?: T, options?: SignalOptions<T>): Accessor<T>;
+/**
+ * Creates a new computation whose value is computed and returned by the given function. The given
+ * compute function is _only_ re-run when one of it's dependencies are updated. Dependencies are
+ * are all signals that are read during execution.
+ */
+export declare function createMemo<T>(compute: (prev?: T) => T, initialValue?: T, options?: SignalOptions<T>): Accessor<T>;
+/**
+ * Invokes the given function each time any of the signals that are read inside are updated
+ * (i.e., their value changes). The effect is immediately invoked on initialization.
+ */
+export declare function createEffect<T>(compute: () => T, effect: (v: T) => (() => void) | void, initialValue?: T, options?: {
+    name?: string;
+}): void;
+/**
+ * Invokes the given function each time any of the signals that are read inside are updated
+ * (i.e., their value changes). The effect is immediately invoked on initialization.
+ */
+export declare function createRenderEffect<T>(compute: () => T, effect: (v: T) => (() => void) | void, initialValue?: T, options?: {
+    name?: string;
+}): void;
+/**
+ * Creates a computation root which is given a `dispose()` function to dispose of all inner
+ * computations.
+ */
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T)): T;
+/**
+ * Runs the given function in the given owner so that error handling and cleanups continue to work.
+ *
+ * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
+ */
+export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T | undefined;
+/**
+ * Runs the given function when an error is thrown in a child owner. If the error is thrown again
+ * inside the error handler, it will trigger the next available parent owner handler.
+ */
+export declare function catchError<T>(fn: () => T, handler: (error: unknown) => void): void;

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

@@ -0,0 +1,5 @@
+export type { Store, StoreSetter, StoreNode, NotWrappable } from "./store.js";
+export type { Merge, Omit } from "./utilities.js";
+export { unwrap, isWrappable, createStore, createProjection, $RAW, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { reconcile } from "./reconcile.js";
+export { merge, omit } from "./utilities.js";

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

@@ -0,0 +1 @@
+export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => void;

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

@@ -0,0 +1,40 @@
+import { Computation } from "../core/index.js";
+export type Store<T> = Readonly<T>;
+export type StoreSetter<T> = (fn: (state: T) => void) => void;
+type DataNode = Computation<any>;
+type DataNodes = Record<PropertyKey, DataNode>;
+declare const $RAW: unique symbol, $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol;
+export declare const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
+export { $PROXY, $TRACK, $RAW, $TARGET };
+export type StoreNode = {
+    [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_NODE]?: DataNodes;
+    [STORE_HAS]?: DataNodes;
+};
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
+export declare function wrap<T extends Record<PropertyKey, any>>(value: T): T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+/**
+ * Returns the underlying data in the store without a proxy.
+ * @param item store proxy object
+ * @example
+ * ```js
+ * const initial = {z...};
+ * const [state, setState] = createStore(initial);
+ * initial === state; // => false
+ * initial === unwrap(state); // => true
+ * ```
+ */
+export declare function unwrap<T>(item: T, deep?: boolean, set?: Set<unknown>): T;
+export declare function createStore<T extends object = {}>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void, store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+/**
+ * Creates a mutable derived value
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
+ */
+export declare function createProjection<T extends Object>(fn: (draft: T) => void, initialValue?: T): Readonly<T>;

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

@@ -0,0 +1,29 @@
+type DistributeOverride<T, F> = T extends undefined ? F : T;
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
+        [K in keyof T]: any;
+    } & {
+        [K in keyof U]?: any;
+    } & {
+        [K in U extends any ? keyof U : keyof U]?: any;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+type _Merge<T extends unknown[], Curr = {}> = T extends [
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
+export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export type Omit<T, K extends readonly (keyof T)[]> = {
+    [P in keyof T as Exclude<P, K[number]>]: T[P];
+};
+export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1 @@
+export declare function isUndefined(value: any): value is undefined;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@solidjs/signals",
+  "version": "0.0.1",
+  "description": "",
+  "license": "ISC",
+  "type": "module",
+  "main": "dist/node.cjs",
+  "module": "dist/prod.js",
+  "types": "dist/types/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
+    "@types/node": "^20.5.1",
+    "rimraf": "^5.0.1",
+    "tsup": "^7.2.0",
+    "typescript": "5.1.6",
+    "vite": "^5.4.10",
+    "vitest": "^2.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": {
+        "test": "./dist/dev.js",
+        "development": "./dist/dev.js",
+        "default": "./dist/prod.js"
+      },
+      "require": "./dist/node.cjs"
+    }
+  },
+  "scripts": {
+    "build": "rimraf dist && tsup && pnpm types",
+    "types": "tsc -p tsconfig.build.json",
+    "format": "prettier src tests --write --log-level warn",
+    "sandbox": "node ./.sandbox/launch.js",
+    "test": "vitest run",
+    "test:watch": "vitest watch tests",
+    "test:gc": "node --expose-gc ./vitest.js",
+    "test:gc:watch": "node --expose-gc ./vitest.js --watch",
+    "test:coverage": "vitest run --coverage",
+    "bench": "vitest bench --run"
+  }
+}