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

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

@@ -1,3 +1,4 @@
+import { type Transition } from "./scheduler.js";
 import type { Computed, NodeOptions, Owner } from "./types.js";
 export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
@@ -5,7 +6,13 @@ export interface Effect<T> extends Computed<T>, Owner {
     _modified: boolean;
     _prevValue: T | undefined;
     _type: number;
-    _boundRunEffect?: () => void;
+    _boundRunEffect?: (type: number) => void;
+    /** The transaction whose staged view produced `_value` (null = committed
+     * view). Effects have one value slot and do not entangle transactions, so
+     * a second transaction recomputing the same effect overwrites a value the
+     * first one still owes a run for; see the contested-effect arm of recompute
+     * (#3322). */
+    _valueTransition: Transition | null;
 }
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are

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

@@ -9,5 +9,6 @@ export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, N
 export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.js";
 export { action } from "./action.js";
 export { flush, Queue, GlobalQueue, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.js";
-export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.js";
+export type { AttributionHooks, InteractionRef, NavigationRef, OriginRef } from "./attribution-hooks.js";
+export { DEV, OBSERVE, type AttributionSlot, type Dev, type Observe, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type DiagnosticListener, type Diagnostics, type DiagnosticSeverity, type DiagnosticSubject } from "./dev.js";
 export * from "./constants.js";

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

@@ -26,12 +26,19 @@ export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
 export declare function findLane(lane: OptimisticLane): OptimisticLane;
 /**
  * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
- * under it); the transaction's reporter map records the async a render effect
+ * under it); a transaction's reporter map records the async a render effect
  * OBSERVED pending with no boundary taking it (INV-3, the one registration
  * site). A hold needs both — the same rule the transaction itself uses, so a
  * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
  * a frame and holds nothing (#3289). An orphan lane has no observation record
  * and never holds.
+ *
+ * The observation is looked up per NODE, in whichever live transaction
+ * recorded it — not in this lane's transaction. Lanes merge across
+ * transactions (#2912: ownership never travels through lanes), so after a
+ * merge the root's transaction holds the observations of only one member;
+ * the async the other member's transaction observed must hold the merged
+ * reveal just the same (A15 for lanes, #3335).
  */
 export declare function laneHeld(lane: OptimisticLane): boolean;
 /**

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

@@ -8,6 +8,11 @@ export declare const zombieQueue: Heap;
 export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
+/** > 0 while an action's generator body is on the stack (the synchronous
+ * slice between yields). Maintained by action.ts around `it.next()`. */
+export declare let actionStepDepth: number;
+export declare function enterActionStep(): void;
+export declare function exitActionStep(): void;
 export declare let _hitUnhandledAsync: boolean;
 /**
  * Consume the unhandled-async hit. Returns whether this is the first report
@@ -43,6 +48,11 @@ export interface Transition {
     _queueStash: QueueStub;
     _done: boolean | Transition;
     _gatedSubs: Set<Computed<any>>;
+    /** Effects whose single value slot was written under this transaction AND
+     * another live one (#3322). Re-dirtied at commit, ahead of the effect
+     * phase, so the run publishes a value derived from the committed world
+     * rather than whichever transaction's staged view wrote last. */
+    _contested: Computed<any>[] | null;
 }
 /**
  * Flip-entanglement (#3164 follow-up): `until()` is a declaration of
@@ -131,6 +141,11 @@ export declare class GlobalQueue extends Queue {
     static _drainPatchOptimistic: (() => void) | null;
     static _gatedRead: ((el: Signal<any>, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
     static _laneSuspends: ((owner: OptimisticNode) => boolean) | null;
+    /** Is the node routed through a LIVE lane (`resolveLane`)? read()'s reveal
+     * carve-out asks before showing a foreign-held pending node's committed
+     * value: a lane-derived flight's inputs are already revealed through the
+     * lane (#3334). Gated on CONFIG_HAS_LANE, which only the engine sets. */
+    static _laneLive: ((el: Computed<any>) => boolean) | null;
     static _laneReadsCommitted: ((el: OptimisticNode, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
     static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
     static _laneAsyncPending: ((el: Computed<any>) => void) | null;
@@ -140,6 +155,26 @@ export declare class GlobalQueue extends Queue {
      * the gate holds (#3303). */
     static _notifyAuthoritativeObservers: ((el: Signal<any> | Computed<any>) => void) | null;
     static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
+    /** A18 supersession (#3331): own-source truth `value` landed under an active
+     * override. The engine decides whether the graph re-derives — the value
+     * differs from the override and is not a stale (older-action) answer (mark
+     * the node, demote its lane cascade, notify), or returns to it after an
+     * earlier differing arrival (clear the mark, notify) — and owns the
+     * authoritative-observer wake for a silent confirm. Installed with the
+     * optimistic engine; only reachable on a node that has an override. */
+    static _supersedeOverride: ((el: Signal<any> | Computed<any>, value: unknown) => void) | null;
+    /** read()'s value for a TRACKED reader of a superseded node (#3331): the
+     * staged truth, unless the reader is a stale (render) reader of another
+     * transaction — then the displayed override, as it keeps a foreign
+     * transaction's committed value over its staged write. */
+    static _supersededRead: ((el: Signal<any> | Computed<any>) => unknown) | null;
+    /** setSignal's authoritative (projection-write) landing on an override-
+     * covered node (#3331 store twin): stage the truth for its transaction's
+     * commit whatever its relation to the committed value — a landing equal to
+     * committed still differs from the override — then _supersedeOverride
+     * decides. Installed with the optimistic engine; only reachable on a node
+     * that has an override. */
+    static _landOnOverride: (<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)) => T) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
@@ -154,6 +189,21 @@ export declare let reaskArmed: boolean;
 export declare let notifyEpoch: number;
 export declare function bumpNotifyEpoch(): void;
 export declare function armReaskClear(): void;
+/** Provenance of the work currently running (A18 supersession, #3331): the
+ * invocation sequence of the action whose ambient window this is — set by
+ * action() for each slice; the flush that ends the window clears it — or,
+ * inside an async landing, the sequence captured when that flight was
+ * registered (asyncWrite sets it for the landing's synchronous propagation,
+ * so a sync recompute downstream of the landing — an optimistic wrapper over
+ * the async source — derives under the flight's provenance, and flights it
+ * registers inherit it). 0 is mainline: no action, always the current
+ * question. An override stamps this at its write (`_overrideStamp`); an
+ * answer whose flight an OLDER action issued is a stale question the user
+ * has since changed — it holds silently to commit instead of superseding. A
+ * slow source must not leak back in over a newer intent. Transactions merge,
+ * so the transition object cannot say WHICH action asked; this can. */
+export declare let origin: number;
+export declare function setOrigin(seq: number): number;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
 export declare let storeCommitHook: (() => void) | null;
 export declare function setStoreCommitHook(fn: () => void): void;
@@ -220,6 +270,16 @@ export declare function flush<T>(fn: () => T): T;
  * initTransition; it is a plain batch until then. */
 export declare function createTransition(): Transition;
 export declare function currentTransition(transition: Transition): Transition;
+/**
+ * The live transition blocked on `source` — the one whose render reader
+ * observed it pending (INV-3 records the observation in whichever transaction
+ * was active when the reader was notified). The observation is a fact about
+ * the node, so a hold check must not assume it was recorded in the transaction
+ * it happens to hold — lanes merge across transactions (#2912), and a merged
+ * root's transaction knows nothing of the async its members' transactions
+ * observed (#3335). Null when nobody is waiting.
+ */
+export declare function waitingTransition(source: Computed<any>): Transition | null;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
 /** Run `fn` with `transition` as BOTH the ambient transaction and the

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

@@ -68,6 +68,16 @@ export interface NodeExtension {
      * layer's STORE_OPTIMISTIC_OWNERS stamps (#2899). `null` = ambient write.
      */
     _overrideOwner: Transition | null | undefined;
+    /** `clock` at the active override's write. A sync recompute in the same
+     * tick derives from inputs that predate the override and does not
+     * supersede it (A18 supersession ordering, #3331). */
+    _overrideTime: number;
+    /** Provenance of the active override's write: the scheduler's `origin` (the
+     * asking action's invocation sequence; 0 = mainline). An arriving answer
+     * whose flight an older action issued asked a question the override has
+     * since changed: it holds to commit instead of superseding (A18
+     * supersession provenance, #3331). */
+    _overrideStamp: number;
     _optimisticLane: OptimisticLane | undefined;
     _pendingSignal: Signal<boolean> | undefined;
     _latestValueComputed: Computed<any> | undefined;
@@ -112,13 +122,19 @@ export interface NodeExtension {
 export interface RawSignal<T> {
     _subs: Link | null;
     _subsTail: Link | null;
+    _value: T;
     /**
-     * DEV-only live subscriber count. Maintained by `link`/`unlinkSubs` for
-     * graph-size diagnostics; undefined in production.
+     * Observe-tier label (`name` option, or the node kind: `signal`,
+     * `computed`, `effect`…). A slot in the observe/dev literals — never a
+     * post-construction write — and absent from the prod literals entirely.
      */
-    _subCount?: number;
-    _value: T;
     _name?: string;
+    /**
+     * Observe-tier: the owner in scope when a user-facing signal was created
+     * (`registerGraph`), so diagnostics about the signal get an owner path.
+     * A slot in the observe/dev `signal()` literal; absent from prod.
+     */
+    _owner?: Owner | null;
     _equals: false | ((a: T, b: T) => boolean);
     _config: number;
     _time: number;
@@ -137,7 +153,10 @@ export interface RawSignal<T> {
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
+    /** Doubly-linked child chain on the firewall's extension (`_x._child` is
+     * the head): released leaves unlink in O(1) (#3351). */
     _nextChild: FirewallSignal<unknown> | null;
+    _prevChild: FirewallSignal<unknown> | null;
 }
 export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
 export interface Owner {
@@ -156,15 +175,16 @@ export interface Owner {
     _prevSibling: Owner | null;
     /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
     _x: NodeExtension | null;
+    /**
+     * Observe-tier label: the `name` option, the node kind (`computed`,
+     * `effect`…), or the component label the rendering layer writes on a root
+     * (`<App>`). A slot in the observe/dev literals; absent from prod.
+     */
+    _name?: string;
 }
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
     _depsTail: Link | null;
-    /**
-     * DEV-only live source count. Maintained by `link`/`unlinkSubs` for
-     * graph-size diagnostics; undefined in production.
-     */
-    _depCount?: number;
     /** Recompute-pass counter; bumped when dep revalidation starts. */
     _depGen: number;
     _flags: number;

package/dist/types/index.d.ts

@@ -1,7 +1,14 @@
 export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.js";
-import { type Dev } from "./core/index.js";
+import { type Dev, type Observe } from "./core/index.js";
+/**
+ * Observe tier (diagnostics channel, attribution hook slot + interaction
+ * frame): dev and observe builds. The attribution engine itself is the
+ * `@solidjs/signals/attribution` entry.
+ */
+export declare const OBSERVE: Observe | undefined;
+/** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */
 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.js";
+export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionHooks, AttributionSlot, InteractionRef, NavigationRef, OriginRef, Dev, Observe, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
 export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, refresh, resolve, until, onSettled, onCleanup } from "./signals.js";
 export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { affects } from "./affects.js";

package/dist/types/map.d.ts

@@ -47,6 +47,8 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;
+/** @internal */
+export declare function __smallMoveHits(): number;
 /**
  * Reactively renders a callback `count` times, reusing previously-rendered
  * entries when only the count changes. Underlying helper for `<Repeat>`.

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

@@ -1,6 +1,7 @@
 export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.js";
 export type { Merge, Omit } from "./utils.js";
 export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { mergeSources } from "./utils.js";
 import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.js";
 import type { Refreshable } from "../core/index.js";
 export { createProjectionNext as createProjection } from "./next/projection.js";

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

@@ -15,6 +15,11 @@ export declare function bumpDeep(t: StoreNextTarget): void;
  * the clone path. Consumers that need a complete container (reconcile's
  * diff walks, drafts escaping into other storage) call this. */
 export declare function materializePB(target: StoreNextTarget): void;
+/** Resolve the held committed view (#3074): answers the masked old backing
+ * while the hold is live, and lazily clears a hold whose transition has
+ * committed (transitions merge — resolve through currentTransition, same as
+ * foldHeld's node stamps). */
+export declare function heldMaskView(t: StoreNextTarget): Record<PropertyKey, any> | null;
 /**
  * Adoption (2026-08-16c): the incoming object becomes the committed backing
  * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped

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

@@ -97,9 +97,17 @@ export interface StoreNextTarget {
      * this target (first-read scan, defineProperty, or clone scan). Gates the
      * fold diff's descriptor-safe path and the get trap's descriptor path. */
     a: boolean;
-    /** Accessor scan performed (scan-once on first trap read; adopted data is
-     * not rescanned — legacy-parity behavior). */
-    sc: boolean;
+    /** Accessor scan grade: 0 = not yet scanned (adoption resets — adopted data
+     * is not rescanned until the next draft), 1 = scanned, 2 = scanned and
+     * PLAIN DATA — `Object.prototype` with every own key an enumerable data
+     * property. Grade 2 unlocks the spread clone (cloneRaw), bare-assignment
+     * overlay writes and flatten (#3360); a non-plain defineProperty through
+     * the draft downgrades it to 1. */
+    sc: 0 | 1 | 2;
+    /** Own-key count: exact at scan, then bumped by set-trap writes of keys new
+     * to the container (never decremented — an estimate for the overlay/clone
+     * choice only, #3360). */
+    kc: number;
     /** Adoption diff base, non-null when the backing was swapped by adoption
      * this batch: the view the nodes were LAST TOLD — the pre-batch committed
      * backing, or the draft's pending backing when a draft preceded the
@@ -110,7 +118,9 @@ export interface StoreNextTarget {
      * (`Object.create(v)` — own keys are this batch's writes, everything else
      * reads through). O(written) per flush instead of O(container) clones
      * (#3044); commit flattens own keys onto an owned committed backing in
-     * place. Only plain-data non-array non-family containers qualify;
+     * place. Plain-data non-array containers qualify, including projection
+     * and derived-store families (#3352); optimistic families, chained
+     * backings, and accessor containers keep the descriptor clone.
      * `materializePB` downgrades to the clone path when a consumer needs a
      * real container (reconcile, draft escape). */
     ovl: boolean;
@@ -134,13 +144,30 @@ export interface StoreNextTarget {
     ht: any;
 }
 /**
- * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
- * backings serving both the production identity-skip guard and the __TEST__
- * no-mutation oracle.
+ * Ownership stamp (#3360): every backing the store ALLOCATES (CoW clones,
+ * privatized committed backings) carries its owning target under this
+ * enumerable symbol. One property write replaces the two weak-collection
+ * registrations (ownership set + raw→target map) a fresh object used to pay
+ * per draft — V8's identity-hash + ephemeron cost dominated the one-key
+ * write floor. Enumerable so a spread copy (the plain-data clone path) stays
+ * on the fast path and carries the stamp along.
+ *
+ * Owned backings are never user-reachable (`snapshot` copies them, the traps
+ * hide the key), so every raw key walk in the store must skip `$OWNER`, and
+ * ownership is answered by `isOwned` — a user object never carries it.
+ * Overlay drafts (`Object.create(v)` over an owned `v`) inherit the stamp.
  */
-export declare const ownedRaw: WeakSet<object>;
-/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */
+export declare const $OWNER: unique symbol;
+/** raw → target for UNOWNED backings (user-ingested, adopted); owned
+ * backings resolve through their `$OWNER` stamp. Boundary mechanism (O8). */
 export declare const storeNextLookup: WeakMap<object, StoreNextTarget>;
+/** A backing the store allocated and may mutate in place. */
+export declare function isOwned(raw: object): boolean;
+/** raw → target within a family (`null` = plain stores / the global map).
+ * The stamp answers for backings owned by a target OF THAT FAMILY; anything
+ * else (user objects, adoptees, another family's backings the family
+ * re-registered for its own wrapper) resolves through the family's map. */
+export declare function lookupTarget(raw: object, fam: StoreNextFamily | null): StoreNextTarget | undefined;
 /** __TEST__ oracle: every object ingested from a user (never mutate). */
 export declare const ingestedRaw: WeakSet<object> | null;
 export declare function devAssertNeverUserMutation(target: object): void;

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

@@ -21,6 +21,13 @@ type _Merge<T extends unknown[], Curr = {}> = T extends [
     ...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>>;
+/** @internal The flattened sources behind a `merge()` PROXY, or undefined.
+ * Only the proxy form: its writes are no-ops, so the sources are the whole
+ * truth. merge()'s plain-object form also records `$SOURCES` (so nested
+ * merges flatten), but it is a real object callers may mutate afterwards
+ * (html's tagged templates assign props after spreading) — those own writes
+ * live on the object, not in the sources, so it must be read directly. */
+export declare function mergeSources(o: any): any[] | undefined;
 /**
  * Merges multiple props-like objects into a single proxy that *preserves
  * reactivity*. Reads are forwarded to the right-most source that defines the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.7",
+  "version": "2.0.0-rc.8",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -13,12 +13,15 @@
   "publishConfig": {
     "access": "public"
   },
-  "main": "./dist/node.cjs",
+  "main": "./dist/prod/index.js",
   "module": "./dist/prod/index.js",
   "unpkg": "./dist/prod/index.js",
   "jsdelivr": "./dist/prod/index.js",
   "types": "./dist/types/index.d.ts",
   "type": "module",
+  "engines": {
+    "node": ">=22.12.0"
+  },
   "sideEffects": false,
   "files": [
     "dist",
@@ -26,25 +29,26 @@
   ],
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/types/index.d.ts",
-        "test": "./dist/dev.js",
-        "development": "./dist/dev.js",
-        "default": "./dist/prod/index.js"
-      },
-      "require": {
-        "types": "./dist/types-cjs/index.d.cts",
-        "development": "./dist/node.dev.cjs",
-        "default": "./dist/node.cjs"
-      }
+      "types": "./dist/types/index.d.ts",
+      "test": "./dist/dev.js",
+      "development": "./dist/dev.js",
+      "observe": "./dist/observe/index.js",
+      "default": "./dist/prod/index.js"
+    },
+    "./attribution": {
+      "types": "./dist/types/attribution.d.ts",
+      "test": "./dist/dev.attribution.js",
+      "development": "./dist/dev.attribution.js",
+      "observe": "./dist/observe/attribution.js",
+      "default": "./dist/prod/attribution.js"
     },
     "./package.json": "./package.json"
   },
   "scripts": {
     "build": "npm-run-all -nl build:* && pnpm types",
-    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs dist/node.dev.cjs",
-    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
-    "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
+    "build:clean": "rimraf dist/dev dist/prod dist/observe dist/*.js",
+    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/observe && node ./scripts/check-pure.mjs dist/prod && node ./scripts/check-pure.mjs dist/observe",
+    "types": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "test:watch": "vitest watch tests",
     "test:gc": "node --expose-gc ./vitest.js",
@@ -67,4 +71,4 @@
     "vite": "^7.0.0",
     "vitest": "^4.1.6"
   }
-}
+}