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

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

@@ -3,6 +3,7 @@ import { activeLanes, assignOrMergeLane, findLane, type OptimisticLane } from ".
 import type { Computed, Signal } from "./types.js";
 export { activeLanes, assignOrMergeLane, findLane };
 export { getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane } from "./lanes.js";
+export declare const transitions: Set<Transition>;
 export declare const dirtyQueue: Heap;
 export declare const zombieQueue: Heap;
 export declare let clock: number;
@@ -14,6 +15,8 @@ export declare let actionStepDepth: number;
 export declare function enterActionStep(): void;
 export declare function exitActionStep(): void;
 export declare let _hitUnhandledAsync: boolean;
+/** Slot hook's deferral: release this node when its carried state resolves. */
+export declare function deferSlotRelease(node: Signal<any>): void;
 /**
  * Consume the unhandled-async hit. Returns whether this is the first report
  * of the current enforcement window — the caller warns only then.
@@ -45,6 +48,10 @@ export interface Transition {
     _affectsNodes: OptimisticNode[];
     _optimisticStores: Set<any>;
     _actions: Array<Generator<any, any, any> | AsyncGenerator<any, any, any>>;
+    /** An action ran in this transaction (#3427, set by action()): once
+     * `_actions` drains, its bodies are OVER — as opposed to a transaction that
+     * never had one, whose bare optimistic writes live until it settles. */
+    _acted?: boolean;
     _queueStash: QueueStub;
     _done: boolean | Transition;
     _gatedSubs: Set<Computed<any>>;
@@ -73,11 +80,44 @@ export interface Transition {
  */
 export declare function entangleConfirmingTransitions(obs: Computed<any>, target: Transition): void;
 export declare function schedule(): void;
+/**
+ * Parked transactions whose reporter set changed without a write. A
+ * transaction completes when nothing live reports a flight it waits on, but
+ * the flush only judges the ACTIVE transaction: a parked one is re-entered by
+ * a stamped node's landing or an action's resume. A reporter that stops
+ * counting for another reason — its loading boundary flipped to the fallback
+ * (#3375), or it was disposed by ambient work (#3372) — is neither: the
+ * pruning in `reporterBlocksSource` would drop it at the next check, but no
+ * check comes, and the writes held with it stay staged. Such sites record the
+ * transaction here (deduped: one idle pass per transaction, however many
+ * reporters changed); the flush re-enters it on an otherwise idle pass, so
+ * the re-evaluation adopts no unrelated ambient work.
+ */
+export declare const wokenTransitions: Transition[];
+/** Wake every parked transaction — for a site that knows a reporter stopped
+ * counting but not whose (a boundary reset). */
+export declare function wakeParked(): void;
+/** Transactions a mainline tick has PROPOSED against (A34, #3494): a write to a
+ * node one of them holds — the same value or another — is a second proposal
+ * on a contested node, and the tick reveals with the hold ("both are
+ * suggesting a value; if one finished before the other that would be odd").
+ * Entered at the next flush's start, where the ambient batch is adopted;
+ * never from the write itself, which left `activeTransition` set across the
+ * caller's block and made creation after the write the transaction's (A29). */
+export declare const batchJoins: Transition[];
 /**
  * Permanently halts the reactive system. Called when a user error escapes
  * every boundary — app state is undefined at that point, so scheduling stops
  * entirely rather than limping along with a half-applied update.
  */
+/**
+ * The key a root owner carries its client error hook under (`render`'s
+ * `onError`) — registered, so a runtime writes it with no import of the hook
+ * module (core/error-hooks.ts) and no property mangling in the way. Defined
+ * HERE, not there: a runtime that only writes the key must not retain the
+ * hook machinery (pay-for-use).
+ */
+export declare const ROOT_ERROR_HOOK: unique symbol;
 export declare function haltReactivity(cause?: unknown): void;
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */
 export declare function resetErrorHalt(): void;
@@ -91,6 +131,11 @@ export interface IQueue {
     stashQueues(stub: QueueStub): void;
     restoreQueues(stub: QueueStub): void;
     _parent: IQueue | null;
+    /** Loading/error boundary queues (boundaries.ts): the status dimension the
+     * queue consumes, and whether it currently shows content (initialized) or
+     * its fallback (collecting). Read by `reporterBlocksSource`. */
+    _collectionType?: number;
+    _initialized?: boolean;
 }
 export declare class Queue implements IQueue {
     _parent: IQueue | null;
@@ -163,11 +208,29 @@ export declare class GlobalQueue extends Queue {
      * 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;
+    /** The flush's pre-verdict step (#3427): once the transaction's action
+     * bodies have all ended and nothing authoritative is left in flight, the
+     * engine supersedes every override still in force with the truth it
+     * reverts to, so the graph re-derives from it now, as the transaction's
+     * held work, instead of after the flights the overrides fed have landed.
+     * True when it superseded something: the caller re-runs the heap ahead of
+     * the verdict. The engine owns every gate (acted, actions drained, has
+     * overrides, no store edits, no authoritative flight); null without it. */
+    static _endOptimism: ((transition: Transition) => boolean) | 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;
+    /** A tracked read of an active override: the lane outside-view rule
+     * (#3460) and the A18 supersession selection (#3331) — see optimistic.ts. */
+    static _overrideRead: ((el: Computed<any>, c: Computed<any>) => unknown) | null;
+    /** A lane pass's publish for a memo (#3479, lanes stage): the speculative
+     * result becomes a DERIVED override, `_value` stays committed — see
+     * optimistic.ts laneOverride. Set with the engine, which a lane implies. */
+    static _laneOverride: ((el: Computed<any>, value: unknown, lane: OptimisticLane) => void) | null;
+    /** Verdict-layer recompute in progress (companion creation, latest()/
+     * isPending() pulls): never born held — see core.ts enterStagedRead. */
+    static _verdictPull: boolean;
     /** 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
@@ -215,6 +278,15 @@ export declare function setStoreCommitHook(fn: () => void): void;
  * storeCommitHook to stay tree-shakeable. */
 export declare let patchCommitHook: ((batch: Transition) => void) | null;
 export declare function setPatchCommitHook(fn: (batch: Transition) => void): void;
+/** Unchanged passes with a stale dependency tail, waiting on this flush's
+ * verdict (A30, #3469). A pass that changed nothing replaced nothing either —
+ * and cannot know at its own tail whether the flush that ran it will park:
+ * parked, its inputs are held and the committed frame still derives from the
+ * tail (`b() ? b() : a()` computed `1` from the held `b`, equal to the `1` it
+ * had from `a` — with `a` trimmed, the mainline `a = 2` never reached it).
+ * Trimmed when the flush commits; dropped with a park, the tail stays linked
+ * until a committing pass trims it (one spurious recompute at most). */
+export declare const heldTrims: Computed<any>[];
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
 /**
  * Count of live `affects()` registrations across the system (including
@@ -264,6 +336,17 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/**
+ * Does a live reporter of `transition` still observe `source` pending? Dead
+ * reporters (disposed, behind a fallback, no longer reading the source) are
+ * pruned as they are found, and the source's entry with them. Shared by the
+ * settle verdict and the lane's hold check (`waitingTransition`): a live
+ * action parks its transaction without a verdict, so this prune is the only
+ * one an optimistic lane whose last async reader unmounted mid-action ever
+ * gets — without it the lane held on the dead reporter's registration until
+ * the flight it no longer observed landed (#3426).
+ */
+export declare function sourceObserved(transition: Transition, source: Computed<any>, verdict?: Transition): boolean;
 /** A fresh, unentered transaction (#3146): the optimistic store's truth
  * flight DECLARES an owned transaction instead of relying on whatever the
  * ambient adoption machinery stamped on its firewall. Activate it with
@@ -277,9 +360,19 @@ export declare function currentTransition(transition: Transition): Transition;
  * 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.
+ * observed (#3335). Null when nobody is waiting — a registration whose every
+ * reporter has since died is nobody (#3426).
  */
 export declare function waitingTransition(source: Computed<any>): Transition | null;
+/** A landing enters EVERY parked transaction still waiting on `source`, folding
+ * them into the active one (A15: each reveal that discovered the flight
+ * completes at its landing). The fold used to happen as the waiters' stamped
+ * readers recomputed under the landing — recompute re-entering an effect's
+ * stamp — which also folded in writes those readers merely shared a hole
+ * with (#3407); effects no longer re-enter, so the landing folds explicitly.
+ * Live iteration is safe: a merge deletes the outgoing (active) entry and
+ * re-adds the visited one. */
+export declare function enterWaiting(source: Computed<any>): void;
 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

@@ -72,6 +72,9 @@ export interface NodeExtension {
      * tick derives from inputs that predate the override and does not
      * supersede it (A18 supersession ordering, #3331). */
     _overrideTime: number;
+    /** A28: the staged value the last flush left on a HELD node that has since
+     * been rewritten (latest() keeps answering with it); NOT_PENDING otherwise. */
+    _flushedStaged: unknown;
     /** 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

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-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";
+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, ownerPath, configureClientErrors, ROOT_ERROR_HOOK } from "./core/index.js";
 import { type Dev, type Observe } from "./core/index.js";
 /**
  * Observe tier (diagnostics channel, attribution hook slot + interaction
@@ -8,7 +8,7 @@ import { type Dev, type Observe } from "./core/index.js";
 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, AttributionHooks, AttributionSlot, InteractionRef, NavigationRef, OriginRef, Dev, Observe, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
+export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionHooks, AttributionSlot, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, OriginRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, 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/signals.d.ts

@@ -582,12 +582,20 @@ export interface UntilOptions {
  *
  * Must be called *outside* a tracking scope.
  *
+ * Inside an action, call it from a step: after an `await`, put a bare `yield`
+ * before `yield until(...)`. The runtime cannot hook an async generator's
+ * `await` continuation, so the `until(...)` expression — which CREATES the
+ * predicate's reader — would otherwise run outside the transaction; created
+ * there it is born held (A29) and replays only at the commit its own promise
+ * holds open (#3482). See {@link action}.
+ *
  * @example
  * ```ts
  * const send = action(async function* (text: string) {
  *   const clientId = crypto.randomUUID();
  *   setMessages(m => { m.push({ clientId, text, pending: true }); }); // optimistic
  *   await socket.send({ clientId, text }); // fire-and-forget transport
+ *   yield; // re-enter the transaction after the await
  *   // Hold until the live source echoes the write (authoritative view —
  *   // the optimistic row above cannot satisfy this):
  *   yield until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });

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

@@ -1,7 +1,8 @@
 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";
+export { mergeSources, mergeView, viewOf, omitView, sourceKeys, sourceHas, sourceGet, hasStaticKeys, isStatic, resolvedTable, OmitView, MergeView, SOURCE_PLAIN, SOURCE_OMIT, SOURCE_PROXY, SOURCE_MEMO, SOURCE_MERGE, sourceOwners } from "./utils.js";
+export type { SourceKind } 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/optimistic.d.ts

@@ -22,4 +22,4 @@ export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<Pr
  * Authoritative-view reads (until()'s predicate) skip composition entirely:
  * the predicate observes authoritative truth, never the caller's tentative
  * overlay. (Write-side emission callers never run under such a compute.) */
-export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
+export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>, draft?: boolean): Record<PropertyKey, any>;

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

@@ -1,3 +1,4 @@
+import { hasActiveOverride, visibleOverride } from "../../core/core.js";
 import type { Signal } from "../../core/types.js";
 import { type StoreNextFamily, type StoreNextTarget } from "./target.js";
 export declare function wrapNext<T extends Record<PropertyKey, any>>(value: T, parent?: StoreNextTarget | null, parentKey?: PropertyKey | null, fam?: StoreNextFamily | null): T;
@@ -65,9 +66,7 @@ export declare function notifyFold(t: StoreNextTarget, old: Record<PropertyKey,
  * share the instance core reads — cross-module live-binding writes from other
  * store modules were observed not to propagate under the test transform). */
 export declare function runAuthoritative<T>(fn: () => T): T;
-/** Active optimistic override on an armed node (armed slot idles at
- * NOT_PENDING; undefined = unarmed plain node). */
-export declare function hasActiveOverride(node: Signal<any>): boolean;
+export { hasActiveOverride, visibleOverride };
 /** The reading computation is until()'s authoritative-view predicate — same
  * source of truth as core read()'s A17 carve-out (`context`, which persists
  * under untrack). optimisticView()'s composition gate consults exactly this:
@@ -86,8 +85,10 @@ export declare function authoritativeServe(): boolean;
 export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
 /** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
  * emits write-time notifications at outermost exit, applies returned
- * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
- * projection recomputes legitimately write from inside their computed. */
+ * replacements as adoptions. `guard=false` skips the dev guards (owned-scope
+ * write, thenable result) — projection recomputes legitimately write from
+ * inside their computed, and their async derive is handled by the recompute,
+ * not returned through here. */
 export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
 export declare function createStoreNext<T extends Record<PropertyKey, any>>(initialValue: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
 /** True when `proxy` is a SHALLOW store (children served verbatim, slots

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

@@ -179,7 +179,7 @@ export declare function devAssertNeverUserMutation(target: object): void;
  * the optimistic channel entirely. */
 export interface OptStoreHooks {
     notifyOptimisticWrites(t: any, pb: Record<PropertyKey, any>): void;
-    optimisticView(t: any, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
+    optimisticView(t: any, src: Record<PropertyKey, any>, draft?: boolean): Record<PropertyKey, any>;
     applyTentative(t: any, incoming: any, keyFn: ((item: any) => any) | null): void;
     /** #3164 fold: does this live transaction still retain optimism (armed
      * nodes or tracked stores)? Backs the held-truth masks in next/store.ts so

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

@@ -21,12 +21,170 @@ 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. */
+/** @internal What a source ENTRY is, decided once when the view is built
+ * (`merge()` learns it while flattening; `omit()` from its argument) and
+ * carried beside the entry — `MergeView.kinds[i]`, `OmitView.kind` — so no
+ * read has to ask. Asking is the cost: any brand check on a Proxy is a trap
+ * (`instanceof` is a `getPrototypeOf` trap, ~20 ns on a store — as much as
+ * the read itself), and a merge over a store did two per read. */
+export declare const SOURCE_PLAIN = 0;
+export declare const SOURCE_OMIT = 1;
+export declare const SOURCE_PROXY = 2;
+export declare const SOURCE_MEMO = 3;
+export declare const SOURCE_MERGE = 4;
+export type SourceKind = 0 | 1 | 2 | 3 | 4;
+/** @internal The record behind an `omit()` proxy: `source` with `hidden`
+ * keys removed. It is the proxy's TARGET, so the shared handler reads it as
+ * plain fields — no per-instance closures — and it is what props consumers
+ * walk directly (`merge`, `spread`, `ssrElement`): a view never materializes
+ * a copy, and a consumer that knows the record never goes through its traps
+ * (a `getOwnPropertyDescriptor` trap per key allocates a descriptor and a
+ * getter, so enumerating a proxy costs more than the copy it was avoiding).
+ * `hidden` is a key list or a predicate (`omit(props, k => k[0] === "$")`).
+ *
+ * An omit over a `merge()` holds the merge's RECORD (`MergeView`, kind
+ * `SOURCE_MERGE`) — never its proxy, so no read hops through a trap — and is
+ * one record however many leaves the merge has. A consumer walks it as ONE
+ * filtered entry (`sourceKeys` / `sourceGet` recurse into the merge's
+ * sources by function call), and a later `merge()` over it carries the
+ * record as one entry instead of copying its leaves: on a component chain of
+ * defaults + omit + spread (`merge(omit(merge(omit(props))))`) the layers
+ * nest as records, each a few fields, where a flatten to leaf views built a
+ * view and a combined key list per leaf per layer — the largest allocation
+ * of a Kobalte-shaped render. A merge leaf may be merge's memo for a
+ * function source; it is resolved on access. */
+export declare class OmitView {
+    source: any;
+    /** of `source` — PLAIN, PROXY (a store or a foreign proxy), MEMO, or
+     * MERGE (a `MergeView` record); never OMIT, a view over a view folds
+     * into one. */
+    kind: SourceKind;
+    hidden: Hidden;
+    /** see `MergeView.table` */
+    table: Map<PropertyKey, any> | null | number;
+    /** see `tableOwnKeys` / `tableDescriptor` */
+    keys: (string | symbol)[] | undefined;
+    descs: Map<PropertyKey, PropertyDescriptor> | undefined;
+    constructor(source: any, 
+    /** of `source` — PLAIN, PROXY (a store or a foreign proxy), MEMO, or
+     * MERGE (a `MergeView` record); never OMIT, a view over a view folds
+     * into one. */
+    kind: SourceKind, hidden: Hidden);
+}
+type Hidden = PropertyKey[] | ((key: PropertyKey) => boolean);
+/** @internal The `OmitView` behind an `omit()` proxy, or undefined. */
+export declare function omitView(o: any): OmitView | undefined;
+/** @internal Own string keys of a source entry — every consumer skips
+ * symbols itself. */
+export declare function sourceKeys(s: any, kind: SourceKind): (string | symbol)[];
+/** @internal `key in entry`. */
+export declare function sourceHas(s: any, kind: SourceKind, key: PropertyKey): boolean;
+/** @internal `entry[key]` — the source's getter runs once, here. */
+export declare function sourceGet(s: any, kind: SourceKind, key: PropertyKey): any;
+/** @internal Whether the own key set of a props object cannot change
+ * reactively: a plain object, or a merge/omit view over plain objects only.
+ * A consumer may then decide from `Object.getOwnPropertyDescriptor` once —
+ * "no `children` key" or "a data `children`" holds for the object's lifetime,
+ * so no tracking scope is needed for it (#3388). For a store, or a view with
+ * a store or memo leaf, keys can appear later and the reactive path is the
+ * only correct one. */
+export declare function hasStaticKeys(o: any): boolean;
+/**
+ * Whether `o[key]` can never change for the lifetime of `o`: the key is a
+ * data property of a plain object, or is absent from an object whose key set
+ * is fixed. A getter, a key on a store, a memo-backed `merge()` source, or
+ * any key of an object whose keys can appear later (a store) is not static.
+ *
+ * Looks through `merge()`/`omit()` views to the leaf that owns the key. Any
+ * object will do, but props are the case it exists for: the compiler encodes
+ * a literal at the call site (`as="button"`) as a data property and an
+ * expression (`as={isLink() ? "a" : "button"}`) as a getter, so a component
+ * library reads the caller's own static/dynamic classification of a prop at
+ * runtime — identically on server and client, the compiled shape being the
+ * same on both — and can take a no-computation path for the literal:
+ *
+ * ```tsx
+ * const Tag = dynamic(() => props.as, { static: isStatic(props, "as") });
+ * ```
+ *
+ * One descriptor lookup; no read of the value, nothing tracked.
+ */
+export declare function isStatic(o: object, key: PropertyKey): boolean;
+/** @internal */
+export declare class MergeView {
+    sources: any[];
+    /** `kinds[i]` is what `sources[i]` is (see `SourceKind`). */
+    kinds: SourceKind[];
+    /** key → the plain leaf that owns it (later sources win), built by an
+     * enumeration or once the reads have paid for it (see `resolvedTable`)
+     * when every leaf has static keys; `null` when one doesn't. Until then
+     * the slot counts the per-key trap reads so far. One slot rather than a
+     * counter field of its own: a view is built per source per component
+     * layer, and each field initializer is a measurable share of a
+     * constructor that small in the lower JIT tiers. */
+    table: Map<PropertyKey, any> | null | number;
+    /** see `tableOwnKeys` / `tableDescriptor` */
+    keys: (string | symbol)[] | undefined;
+    descs: Map<PropertyKey, PropertyDescriptor> | undefined;
+    constructor(sources: any[], 
+    /** `kinds[i]` is what `sources[i]` is (see `SourceKind`). */
+    kinds: SourceKind[]);
+}
+/** @internal The `MergeView` behind a `merge()` proxy — its flattened
+ * `sources` with their `kinds` — or undefined. */
+export declare function mergeView(o: any): MergeView | undefined;
+/** @internal The record behind a merge() or omit() proxy — a `MergeView`
+ * (flattened `sources` with their `kinds`) or an `OmitView` — or undefined
+ * for anything else (a plain object, a store, a foreign proxy). Two fast
+ * traps on a store, none on a plain object. */
+export declare function viewOf(o: any): MergeView | OmitView | undefined;
+/** @internal The resolved key table of a merge/omit view — every own key of
+ * the view mapped to the plain object that owns it, in merged order (a key
+ * at the position of the last source that carries it, see `tableSet`) — or
+ * undefined when it has none: a leaf is a store or a memo source, whose
+ * keys can change, or the object is not a view at all.
+ *
+ * This is the flat object the eager copy used to build, made lazily and
+ * without copying: one pass over the leaves' own keys, then every
+ * `get`/`has`/descriptor is one lookup plus one read of the owning leaf, and
+ * a consumer (`spread` rerunning its effect) walks the table instead of
+ * re-deriving shadowing from the leaves each time. Own keys only, as the
+ * copy's were: a plain source's key set is fixed once merged (keys added to
+ * it later are not seen — the copy didn't see them either).
+ *
+ * It is built by an ENUMERATION — the `ownKeys` trap, or a consumer asking
+ * for it here — or once per-key reads have paid for it (`READS_FOR_TABLE`),
+ * not on the first read. A per-key read has a direct answer (a walk of the
+ * sources, last to first, one `in` each) whose cost is the source count,
+ * while the table's is every key of every leaf, so the walk wins until a
+ * view has been read about as many times as it has keys. On the server it
+ * never is: a component reads its props a few times, the element enumerates
+ * them once through its own source walk, and the view is gone — building on
+ * first read there cost a component chain a table per layer (profiled on
+ * the Kobalte-shaped chain: a third of SSR time in the table code and its
+ * garbage). On the
+ * client a view read on every reactive rerun crosses the threshold in its
+ * first few updates and is one lookup per read from then on, as before.
+ * Once built — by a `spread`, `Object.keys`, `{...props}`, or the count —
+ * every trap uses it. */
+export declare function resolvedTable(o: any): Map<PropertyKey, any> | undefined;
+/** @internal Every own string key of a props SOURCE — a plain object, a
+ * store or foreign proxy, or a merge/omit view — appended to `keys` in
+ * merged order with the object that owns each at the same index of
+ * `owners`: a key already listed (by this source or an earlier one) moves
+ * to the end, so several sources collected in turn give the order and the
+ * winners a merge of them would. A consumer that reads each key once
+ * (`ssrElement`) then reads `owners[i][keys[i]]` — the owner's getter runs
+ * there, once — and asks nothing else of a view: no table, no `in` walk per
+ * key through the merge/omit layers, no key list per leaf. One pass,
+ * however deep the layers nest. Symbols are listed; the consumer skips
+ * them. */
+export declare function sourceOwners(s: any, keys: (string | symbol)[], owners: any[]): void;
+/** @internal The flattened sources behind a `merge()` proxy, or undefined.
+ * A merge's writes are no-ops, so its sources are the whole truth. A COPY of
+ * a merge (`{...merged}`, a descriptor copy) is a plain object that carries
+ * no sources — `ownKeys` never answers $SOURCES — so what is on the copy is
+ * the truth there and every consumer reads it directly (#3384). */
 export declare function mergeSources(o: any): any[] | undefined;
 /**
  * Merges multiple props-like objects into a single proxy that *preserves
@@ -36,6 +194,12 @@ export declare function mergeSources(o: any): any[] | undefined;
  * Function arguments are treated as memo-backed sources — useful for passing
  * derived defaults whose computation should track reactively.
  *
+ * The result is a live VIEW of its sources, never a copy: creating it costs
+ * nothing per key, every read goes to the source that owns the key (a getter
+ * runs there, a data property is read live), and writing to it is a no-op.
+ * A single non-function source is returned as is. To own a mutable object,
+ * copy it: `{ ...merged }` snapshots the current values.
+ *
  * Use this in component bodies to merge defaults / overrides without losing
  * Solid's per-property tracking.
  *
@@ -59,6 +223,12 @@ export type Omit<T, K extends readonly (keyof T)[]> = {
  * Use it to forward "rest" props to a child element while pulling out the
  * keys your component handles itself — the equivalent of `splitProps(p, ["a","b"])[1]`.
  *
+ * The result is a live VIEW of `props`, not a copy: nothing is read or
+ * materialized until a key is used, and a spread (`{...rest}`) or a later
+ * `merge()` walks the underlying object directly. A predicate hides keys by
+ * rule instead of by name — `omit(props, k => k[0] === "$")` — without
+ * enumerating first.
+ *
  * @example
  * ```tsx
  * function Input(props: { label: string; value: string; onInput: (v: string) => void } & JSX.HTMLAttributes<HTMLInputElement>) {
@@ -78,4 +248,5 @@ export type Omit<T, K extends readonly (keyof T)[]> = {
  * ```
  */
 export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export declare function omit<T extends Record<any, any>>(props: T, hidden: (key: keyof T & (string | symbol)) => boolean): Partial<T>;
 export {};

package/package.json

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