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

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

@@ -1,14 +1,28 @@
-import type { Signal } from "../../core/types.js";
+import { hasActiveOverride, visibleOverride } from "../../core/core.js";
+import type { Computed, 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;
 /** Unwrap our own proxies to their current backing; leave everything else. */
 export declare function unwrapValue(v: any): any;
-export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any): Signal<any>;
+export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any, accKnown?: -1 | 0 | 1): Signal<any>;
+/** Record a store proxy's declared name for attribution labels (observe tiers). */
+export declare function nameStore(proxy: any, name: string | undefined): void;
 export declare function getHasNode(target: StoreNextTarget, key: PropertyKey, present: boolean): Signal<boolean>;
 export declare function getKeySetNode(target: StoreNextTarget): Signal<number>;
 /** Deep-witness bump: any value/shape change on a record with a live deep()
  * subscriber notifies it. One null check when unused. */
 export declare function bumpDeep(t: StoreNextTarget): void;
+/** Downgrade a prototype-overlay pending backing to the clone path: builds
+ * the real container (committed + overlay writes − deletes) that fold will
+ * SWAP in as the committed backing, exactly as if the draft had started on
+ * 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
@@ -18,9 +32,16 @@ export declare function bumpDeep(t: StoreNextTarget): void;
  * authoritative base (R21/R32).
  */
 export declare function adoptPB(target: StoreNextTarget, incoming: Record<PropertyKey, any>, eager?: boolean): void;
+/** Parked truth-staged pending backings (#3164 fold): a tentative draft that
+ * opens while a folded landing's backing is live moves the staged container
+ * here (see ensurePB); the tentative discard in notifyOptimisticWrites
+ * restores it in place of the usual null. */
+export declare const stagedTruthPB: WeakMap<StoreNextTarget, Record<PropertyKey, any>>;
 /** Same logical slot: both values resolve to one (re-pointed) child target —
  * adoption preserved identity, so the slot did not change (R9). */
 export declare function targetsEqual(ov: any, nv: any): boolean;
+export declare function arrayStructureChanged(old: any[], neu: any[]): boolean;
+export declare function membershipChanged(old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): boolean;
 /**
  * The fold diff walks SUBSCRIPTION KEYS ONLY (legacy parity: `for key in
  * nodes`): nodes exist exactly where something tracked, so unobserved data
@@ -47,18 +68,69 @@ 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:
+ * write-side machinery (patch emission, tentative re-application) must keep
+ * composing even when it runs inside an authoritative-write bracket. */
+export declare function authoritativeRead(): boolean;
+/** Serve-side authoritative gate: until()'s predicate PLUS truth authors —
+ * the projection derive's draft (wrapDraft trap brackets, runAuthoritative;
+ * the same posture pair ensurePB classifies drafts by). A source computing
+ * the next truth must never read its callers' tentative overlays: a derive
+ * continuation's `store.push` computing its index from an action's
+ * optimistic row landed truth in the wrong slot and corrupted committed
+ * state (#3108). Trap-level overlay serves gate on this so values, length,
+ * membership, and keys leave the authoritative view together. */
+export declare function authoritativeServe(): boolean;
+/** The override a composed READER view (keys, descriptors, snapshot/deep,
+ * optimisticView) takes from an armed node whose override is active — the
+ * override itself, unless the node's own source superseded it (#3331,
+ * CONFIG_OVERRIDE_SUPERSEDED): then the reader-aware selection `serve`
+ * makes through nodeValue, so the composed view agrees with what `get`,
+ * `in` and `length` serve the same reader (a deriving pass: the staged
+ * truth; a lane pass or a context-free read: the override, A18). Composing
+ * the raw override left Object.keys / snapshot() / deep() one row behind the
+ * traps at a landing whose shape differed from the optimistic frame (F5
+ * parity cases). Draft and authoritative callers never reach here — the
+ * writer composes on hasActiveOverride, truth authors on the backing. */
+export declare function readerOverride(node: Signal<any>, committed: any): any;
 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. */
+/** The derived store's setter (CS-R31): within a synchronous frame the manual
+ * write wins — the projection's recompute is masked for the tick. Across a
+ * hold the write is not a proposal: a leaf the fold staged under another
+ * transaction re-runs the fold under it, the write being the draft's prior
+ * state (#3612). Decided from the leaf notifications, so the mask lands
+ * after them (in the `finally`: a throwing setter's writes before the throw
+ * were notified, and are masked as before). */
+export declare function derivedStoreWrite<T>(node: Computed<unknown>, proxy: T, fn: (draft: T) => T | void): void;
 export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
-export declare function createStoreNext<T extends Record<PropertyKey, any>>(init: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
+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
+ * replaced by reference — #2932). The list driver uses this to choose the
+ * slot-patch channel (collected row bodies) over per-record registration. */
+export declare function storeIsShallow(proxy: any): boolean;
+/** True when `proxy` belongs to a projection/optimistic FAMILY. The list
+ * driver must DECLINE family arrays (external audit finding): family
+ * structural changes never emit row/slot ops (the setter channel is
+ * fam-gated; optimistic writes ride node overrides), and the proxy identity
+ * is stable so the each-watch cannot catch the change either — an engaged
+ * list would freeze on optimistic/projection structural updates. Record-
+ * level family patches are unaffected (they have their own emission). */
+export declare function storeHasFamily(proxy: any): boolean;
+/** True when `proxy` belongs to an OPTIMISTIC family specifically. The list
+ * driver declines these (audit finding, narrowed): optimistic user writes
+ * ride node-level overrides — they never enter the reconcile walk, so no
+ * row/slot ops are emitted and an engaged list would freeze on optimistic
+ * structural changes. PROJECTION (non-optimistic) families are drivable:
+ * their recomputes go through the reconcile walk, whose emissions are
+ * transition-stamped in the apply queue like any other (equivalence-matrix
+ * gated). Re-admitting optimistic families requires a lane-timed structural
+ * emission mirroring emitPatchOptimistic, plus revert resync. */
+export declare function storeHasOptimisticFamily(proxy: any): boolean;
 /** Tracking deep snapshot (`deep()` for next targets): subscribes to the
- * key-set and every property node at every reachable level, then returns the
+ * key-set and deep-witness node at every reachable level, then returns the
  * plain view. Shared references and cycles handled via the visited set. */
 export declare function deepNext<T>(value: T): T;
 /**

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

@@ -27,10 +27,34 @@ export interface StoreNextFamily {
     /** Targets currently carrying active node overrides (landing-consumption
      * walk, RUL-2: visible landed truth replaces optimism). */
     overlaid?: Set<any>;
+    /** Retaining transactions (#3164 fold ruling): every transaction that made
+     * an optimistic setter call on this family and may still be open. While
+     * any member is live, truth landings FOLD — they stage into the retaining
+     * transaction and reveal atomically at its settle, exactly like a signal
+     * landing under an active override. Dead members prune lazily at each
+     * landing (retainingTransition). */
+    rt?: Set<any>;
+    /** Flight-owned transaction (#3146): declared when a truth-flight
+     * registers (the ask's transaction — created by the flight's own pending
+     * throw when none was ambient, the causing write's when one was), renewed
+     * per settle event once the previous reveal committed. Bare optimistic
+     * writes and landings route into it BY DECLARATION; the transitionBlocked
+     * store-half checks it for ownership instead of reconstructing it from
+     * `_optimisticStores` membership. null = no flight declared one (sync
+     * derive, or a loading-window flight — the loading rail is
+     * transaction-invisible, #2933). */
+    ft?: any;
+    /** Normalized row-key fn (same resolution as the projection channels:
+     * `options.key`, "id" default, null = unkeyed). The staged-landing walk
+     * reads it: key-matched rows keep their proxy identity across a fold. */
+    key?: ((item: any) => any) | null;
     map: WeakMap<object, StoreNextTarget>;
     /** The projection computed — assigned after creation (accessor pattern). */
     node: Computed<any> | null;
     shallow?: boolean;
+    /** Derive run counter (proj R37): the run whose draft is live. A draft
+     * compares its own run against this — the next run's start supersedes it. */
+    run?: number;
 }
 export interface StoreNextTarget {
     /** Committed backing: source object (shared) or owned clone. */
@@ -47,6 +71,19 @@ export interface StoreNextTarget {
     h: Record<PropertyKey, Signal<boolean>> | null;
     /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
     k: Signal<number> | null;
+    /** Keys written through the traps since the last fold commit. Bounds the
+     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
+     * a record with thousands of per-key subscriptions (selection maps) would
+     * otherwise pay a full node scan on every write. null = no trap writes
+     * this batch (bulk paths fall back to the full scan); WK_ALL = bound
+     * unusable (array length write). LOAD-BEARING SHAPE RULE: array proxy
+     * targets carry their fields as named properties on a real array, and V8
+     * normalizes an array to dictionary properties as the named count grows
+     * (empirically at counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap
+     * field read then becomes a hash lookup (~15% uibench, tree suites
+     * worst). Future write-side state MUST ride an extension object, not new
+     * named fields. */
+    wk: Set<PropertyKey> | null;
     /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
      * of one per path; write paths bump it only when it exists. Separate from
      * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */
@@ -63,24 +100,77 @@ 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;
-    /** Backing was swapped by adoption this batch (fold diff-notifies it). */
-    adopted: 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
+     * adoption (its setter-exit notifications already moved the nodes, #3296).
+     * The deferred fold diffs incoming against this, never against committed. */
+    ab: Record<PropertyKey, any> | null;
+    /** Pending backing is a prototype-chain OVERLAY of the committed backing
+     * (`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. 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;
+    /** Keys deleted in the overlay window (a prototype overlay cannot shadow
+     * a delete); null when none. */
+    del: Set<PropertyKey> | null;
     /** Projection family, null for plain stores (§7b). */
     fam: StoreNextFamily | null;
     /** Shallow store root (values served raw). */
     s: boolean;
+    /** Held committed view (#3074/#3075): the pre-hold committed backing,
+     * served to committed-visibility readers while `ht` is live. Adoption is
+     * eager by contract, but a projection recompute deriving from uncommitted
+     * inputs (a transition-held source, or a latest()-pull ahead of the flush)
+     * swaps the backing SPECULATIVELY — the old view must stay servable until
+     * the hold resolves. */
+    hv: Record<PropertyKey, any> | null;
+    /** The holder for `hv`: a live transition (cleared lazily when it is done)
+     * or the PLAIN_HOLD sentinel (a latest()-pull staging — cleared by the
+     * fold commit). null = no hold. */
+    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;
@@ -92,8 +182,15 @@ 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
+     * plain-store bundles don't carry the transition-optimism probe. */
+    retainsOptimism(t: any): boolean;
 }
 export declare let optHooks: OptStoreHooks | null;
 export declare function setOptHooks(h: OptStoreHooks): void;
+/** Sticky descendants flag walk (§6d): reconcile's keyed pruning descends
+ * only where subscriptions exist at/below. Nodes AND patches count. */
+export declare function markDescendants(target: StoreNextTarget): void;

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

@@ -1,7 +1,7 @@
 import { type Signal } from "../core/index.js";
 import type { Refreshable } from "../core/index.js";
-/** A read-only view of a store's value as seen by consumers. Mutate it via the paired `StoreSetter`. */
-export type Store<T> = Readonly<T>;
+/** A reactive view of a store's value. Update it through the paired `StoreSetter`. */
+export type Store<T> = T;
 /**
  * A store setter. The callback receives a writable **draft** of the store.
  *
@@ -14,25 +14,34 @@ export type Store<T> = Readonly<T>;
  *
  * The setter does **not** perform keyed reconciliation. If you need surviving
  * items to keep their store identity across full-array replacement, use the
- * projection form — `createStore(fn, seed, { key })` or `createProjection` —
- * whose derive function reconciles its return by `options.key`.
+ * projection form — `createStore(fn, seed, { key })` or
+ * `createProjection(fn, seed, { key })` — whose derive function reconciles
+ * its return by `options.key`.
  */
 export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
-/** Tuple returned by the plain `createStore(initialValue)` form. */
+/** Tuple returned by the plain `createStore(initialValue, options?)` form. */
 export type StoreReturn<T> = [get: Store<T>, set: StoreSetter<T>];
 /** Tuple returned by the derived `createStore(fn, seed, options?)` form. */
 export type ProjectionStoreReturn<T> = [get: Refreshable<Store<T>>, set: StoreSetter<T>];
-/** Base options for store primitives. */
+/** Options shared by all store primitives. */
 export interface StoreOptions {
-    /** Debug name (dev mode only) */
+    /**
+     * Debug name (dev and observe builds). Property nodes are labelled
+     * `<name>.<key>` in attribution output (`todos.title`); a derived store's
+     * projection node carries the name itself.
+     */
     name?: string;
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
 }
-/** Options for derived/projected stores created with `createStore(fn)`, `createProjection`, or `createOptimisticStore(fn)`. */
+/**
+ * Options for derived/projected stores created with
+ * `createStore(fn, seed, options?)`, `createProjection(fn, seed, options?)`,
+ * or `createOptimisticStore(fn, seed, options?)`.
+ */
 export interface ProjectionOptions extends StoreOptions {
     /** Key property name or function for reconciliation identity; `null` merges positionally */
     key?: string | ((item: NonNullable<any>) => any) | null;
-    /** Single-layer store: root keys reactive, values raw records replaced by reference */
-    shallow?: boolean;
     /**
      * Treat the seed as commit #0: the store is born committed with the seed's
      * contents, shown until the derive's first real answer lands. While that
@@ -57,7 +66,7 @@ type DataNodes = Record<PropertyKey, DataNode>;
  *
  * @internal
  */
-export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol, $AFFECTS: unique symbol;
+export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $RECORD: unique symbol, $DELETED: unique symbol, $AFFECTS: unique symbol;
 export declare const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
 /** Structural view of a store target as shared machinery sees it (the real
  * shape is `StoreNextTarget` in ./next/target.ts). */

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

@@ -21,6 +21,173 @@ 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 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 compiler emitting the same
+ * own DESCRIPTORS on both (the object behind them may differ: the server
+ * builds props as a plain-prototype instance with shared getters) — 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 proxy (`has`, then `$RECORD`), 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 lists $RECORD — 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
  * reactivity*. Reads are forwarded to the right-most source that defines the
@@ -29,9 +196,23 @@ export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
  * 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.
  *
+ * Reading props, here and anywhere: a prop's getter is defined only for a
+ * read through its own object (`props.x`, `{ ...props }`, `Reflect.get`,
+ * these views). Forwarding its descriptor onto another object and reading it
+ * there is not supported — the compiler's server-side props keep their state
+ * on the instance, so the getter needs its object as receiver. A copy that
+ * must stay live defines its own getter that reads through the source, as
+ * the no-Proxy paths of merge() and omit() do.
+ *
  * @example
  * ```tsx
  * function Button(_props: { label: string; type?: string; disabled?: boolean }) {
@@ -52,6 +233,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>) {
@@ -71,4 +258,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 {};