diff --git a/packages/store/src/core/config.ts b/packages/store/src/core/config.ts
index 6e4f1bb7..24dc8798 100644
--- a/packages/store/src/core/config.ts
+++ b/packages/store/src/core/config.ts
@@ -1,4 +1,4 @@
-import type { AnyFeature, UnionFeatureTarget } from './feature';
+import type { AnyFeature, UnionFeatureState, UnionFeatureTarget } from './feature';
 import type { TaskKey } from './queue';
 import type { RequestMeta } from './request';
 import type { Store } from './store';
@@ -9,28 +9,32 @@ export interface PendingTask {
   startedAt: number;
 }
 
-export interface StoreConfig<Features extends AnyFeature[]> {
+export interface StoreConfig<Features extends AnyFeature[]>
+  extends StoreCallbacks<UnionFeatureTarget<Features>, UnionFeatureState<Features>> {
   features: Features;
-  onSetup?: (ctx: StoreSetupContext<Features>) => void;
-  onAttach?: (ctx: StoreAttachContext<Features>) => void;
-  onError?: (ctx: StoreErrorContext<Features>) => void;
+}
+
+export interface StoreCallbacks<Target, State> {
+  onSetup?: (ctx: StoreSetupContext<Target, State>) => void;
+  onAttach?: (ctx: StoreAttachContext<Target, State>) => void;
+  onError?: (ctx: StoreErrorContext<Target, State>) => void;
   onTaskStart?: (ctx: StoreTaskContext) => void;
   onTaskEnd?: (ctx: StoreTaskContext & { error?: unknown }) => void;
 }
 
-export interface StoreSetupContext<Features extends AnyFeature[]> {
-  store: Store<Features>;
+export interface StoreSetupContext<Target, State> {
+  store: Store<Target, State>;
   signal: AbortSignal;
 }
 
-export interface StoreAttachContext<Features extends AnyFeature[]> {
-  store: Store<Features>;
-  target: UnionFeatureTarget<Features>;
+export interface StoreAttachContext<Target, State> {
+  store: Store<Target, State>;
+  target: Target;
   signal: AbortSignal;
 }
 
-export interface StoreErrorContext<Features extends AnyFeature[]> {
-  store: Store<Features>;
+export interface StoreErrorContext<Target, State> {
+  store: Store<Target, State>;
   error: unknown;
 }
 
diff --git a/packages/store/src/core/feature-selector.ts b/packages/store/src/core/feature-selector.ts
new file mode 100644
index 00000000..30462662
--- /dev/null
+++ b/packages/store/src/core/feature-selector.ts
@@ -0,0 +1,46 @@
+import { pick } from '@videojs/utils/object';
+import { StoreError } from './errors';
+import type { AnyFeature, InferFeatureState, StateFactoryContext } from './feature';
+
+const stateContext: StateFactoryContext<unknown> = {
+  task: () => {
+    throw new StoreError('NO_TARGET');
+  },
+  target: () => {
+    throw new StoreError('NO_TARGET');
+  },
+};
+
+/**
+ * Create a type-safe selector for a feature's state.
+ *
+ * The selector returns the feature's state slice, or `undefined` if the feature
+ * is not configured in the store.
+ *
+ * @example
+ * ```ts
+ * const selectPlayback = createFeatureSelector(playbackFeature);
+ *
+ * function PlayButton() {
+ *   const playback = usePlayer(selectPlayback);
+ *   if (!playback) return null; // Feature not configured
+ *
+ *   return <button onClick={playback.toggle}>{playback.paused ? 'Play' : 'Pause'}</button>;
+ * }
+ * ```
+ */
+export function createFeatureSelector<F extends AnyFeature>(
+  feature: F
+): (state: Record<string, unknown>) => InferFeatureState<F> | undefined {
+  const initialState = feature.state(stateContext);
+  const keys = Object.keys(initialState);
+
+  const firstKey = keys[0];
+  if (!firstKey) return () => undefined;
+
+  return (state) => {
+    // WARN: Could be the source of a bug if two features have overlapping state keys
+    if (!(firstKey in state)) return undefined;
+    return pick(state, keys) as InferFeatureState<F>;
+  };
+}
diff --git a/packages/store/src/core/feature.ts b/packages/store/src/core/feature.ts
index de0faeb0..0b750e33 100644
--- a/packages/store/src/core/feature.ts
+++ b/packages/store/src/core/feature.ts
@@ -9,21 +9,21 @@ const FEATURE_SYMBOL = Symbol('@videojs/feature');
 // Task
 // ----------------------------------------
 
-export type Task<Target, State extends object> = {
+export type Task<Target, State> = {
   <Output>(handler: TaskHandler<Target, State, Output>): Promise<Awaited<Output>>;
   <Output>(options: TaskOptions<Target, State, Output>): Promise<Awaited<Output>>;
 };
 
-export interface TaskOptions<Target, State extends object, Output> {
+export interface TaskOptions<Target, State, Output> {
   key?: TaskKey;
   mode?: TaskMode;
   cancels?: TaskKey[];
   handler: TaskHandler<Target, State, Output>;
 }
 
-export type TaskHandler<Target, State extends object, Output> = (ctx: TaskContext<Target, State>) => Output;
+export type TaskHandler<Target, State, Output> = (ctx: TaskContext<Target, State>) => Output;
 
-export interface TaskContext<Target, State extends object> {
+export interface TaskContext<Target, State> {
   target: Target;
   signal: AbortSignal;
   get: () => Readonly<State>;
@@ -34,13 +34,15 @@ export interface TaskContext<Target, State extends object> {
 // Attach
 // ----------------------------------------
 
-export type Attach<Target, State extends object> = (ctx: AttachContext<Target, State>) => void;
+export type Attach<Target, State> = (ctx: AttachContext<Target, State>) => void;
 
-export interface AttachContext<Target, State extends object> {
+export interface AttachContext<Target, State> {
   target: Target;
   signal: AbortSignal;
   get: () => Readonly<State>;
   set: (partial: Partial<State>) => void;
+  /** Store instance for cross-feature access via selectors. */
+  store: { readonly state: Readonly<State>; subscribe: (callback: () => void) => () => void };
 }
 
 // ----------------------------------------
@@ -57,14 +59,14 @@ export interface StateFactoryContext<Target> {
 // Feature
 // ----------------------------------------
 
-export type StateFactory<Target, State extends object> = (ctx: StateFactoryContext<Target>) => State;
+export type StateFactory<Target, State> = (ctx: StateFactoryContext<Target>) => State;
 
-export interface FeatureConfig<Target, State extends object> {
+export interface FeatureConfig<Target, State> {
   state: StateFactory<Target, State>;
   attach?: Attach<Target, State>;
 }
 
-export interface Feature<Target, State extends object> extends FeatureConfig<Target, State> {
+export interface Feature<Target, State> extends FeatureConfig<Target, State> {
   [FEATURE_SYMBOL]: true;
 }
 
@@ -74,10 +76,8 @@ export type AnyFeature<Target = any> = Feature<Target, any>;
 // Factory
 // ----------------------------------------
 
-export function defineFeature<Target>(): <State extends object>(
-  config: FeatureConfig<Target, State>
-) => Feature<Target, State> {
-  return <State extends object>(config: FeatureConfig<Target, State>): Feature<Target, State> => ({
+export function defineFeature<Target>(): <State>(config: FeatureConfig<Target, State>) => Feature<Target, State> {
+  return <State>(config: FeatureConfig<Target, State>): Feature<Target, State> => ({
     [FEATURE_SYMBOL]: true,
     ...config,
   });
diff --git a/packages/store/src/core/index.ts b/packages/store/src/core/index.ts
index e923d82f..abdbb108 100644
--- a/packages/store/src/core/index.ts
+++ b/packages/store/src/core/index.ts
@@ -1,8 +1,10 @@
 export * from './config';
 export * from './errors';
 export * from './feature';
+export { createFeatureSelector } from './feature-selector';
 export type { TaskKey, TaskMode } from './queue';
 export { CANCEL_ALL } from './queue';
 export * from './request';
+export { shallowEqual } from './shallow-equal';
 export * from './state';
 export * from './store';
diff --git a/packages/store/src/core/shallow-equal.ts b/packages/store/src/core/shallow-equal.ts
new file mode 100644
index 00000000..f248d2bf
--- /dev/null
+++ b/packages/store/src/core/shallow-equal.ts
@@ -0,0 +1,22 @@
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export function shallowEqual<T>(a: T, b: T): boolean {
+  if (Object.is(a, b)) return true;
+
+  if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
+    return false;
+  }
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+
+  if (keysA.length !== keysB.length) return false;
+
+  for (const key of keysA) {
+    if (!hasOwn.call(b, key) || !Object.is((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}
diff --git a/packages/store/src/core/state.ts b/packages/store/src/core/state.ts
index 3ff80b0c..37143c55 100644
--- a/packages/store/src/core/state.ts
+++ b/packages/store/src/core/state.ts
@@ -1,11 +1,13 @@
 export type StateChange = () => void;
 
-export interface State<T extends object> {
+export type UnknownState = Record<string, unknown>;
+
+export interface State<T> {
   readonly current: Readonly<T>;
   subscribe(callback: StateChange): () => void;
 }
 
-export interface WritableState<T extends object> extends State<T> {
+export interface WritableState<T> extends State<T> {
   patch: (partial: Partial<T>) => void;
 }
 
@@ -26,7 +28,7 @@ export function flush(): void {
 
 const hasOwnProp = Object.prototype.hasOwnProperty;
 
-class StateContainer<T extends object> implements WritableState<T> {
+class StateContainer<T> implements WritableState<T> {
   #current: T;
   #listeners = new Set<StateChange>();
   #pending = false;
@@ -79,7 +81,7 @@ class StateContainer<T extends object> implements WritableState<T> {
   }
 }
 
-export function createState<T extends object>(initial: T): WritableState<T> {
+export function createState<T>(initial: T): WritableState<T> {
   return new StateContainer(initial);
 }
 
diff --git a/packages/store/src/core/store.ts b/packages/store/src/core/store.ts
index 6ad7f19b..ad900285 100644
--- a/packages/store/src/core/store.ts
+++ b/packages/store/src/core/store.ts
@@ -15,14 +15,15 @@ import type {
 import { CANCEL_ALL, Queue } from './queue';
 import type { RequestMeta, RequestMetaInit } from './request';
 import { createRequestMeta, createRequestMetaFromEvent } from './request';
-import type { StateChange, WritableState } from './state';
+import type { StateChange, UnknownState, WritableState } from './state';
 import { createState } from './state';
 
 const STORE_SYMBOL = Symbol('@videojs/store');
 
-export function createStore<Features extends AnyFeature[]>(config: StoreConfig<Features>): Store<Features> {
-  type Target = UnionFeatureTarget<Features>;
-  type State = UnionFeatureState<Features>;
+export function createStore<Features extends AnyFeature[]>(config: StoreConfig<Features>): FeatureStore<Features> {
+  type Store = FeatureStore<Features>;
+  type Target = InferStoreTarget<Store>;
+  type State = UnknownState;
 
   const { features } = config;
 
@@ -38,15 +39,14 @@ export function createStore<Features extends AnyFeature[]>(config: StoreConfig<F
   // Reactive state - initialized after building features
   let state: WritableState<State>;
 
-  const stateFactoryContext: StateFactoryContext<Target> = {
+  const initialState = createInitialState({
     task: executeTask,
     target: () => {
       if (!target) throw new StoreError('NO_TARGET');
       return target;
     },
-  };
+  });
 
-  const initialState = createInitialState(stateFactoryContext);
   state = createState(initialState);
 
   const store = {
@@ -67,11 +67,11 @@ export function createStore<Features extends AnyFeature[]>(config: StoreConfig<F
     destroy,
     subscribe,
     meta,
-  } as unknown as Store<Features>;
+  } as unknown as Store;
 
   for (const key of Object.keys(initialState)) {
     Object.defineProperty(store, key, {
-      get: () => (state.current as Record<string, unknown>)[key],
+      get: () => state.current[key],
       enumerable: true,
     });
   }
@@ -116,6 +116,12 @@ export function createStore<Features extends AnyFeature[]>(config: StoreConfig<F
       signal,
       get: () => state.current,
       set: (partial) => state.patch(partial),
+      store: {
+        get state() {
+          return state.current;
+        },
+        subscribe,
+      },
     };
 
     for (const feature of features) {
@@ -127,7 +133,11 @@ export function createStore<Features extends AnyFeature[]>(config: StoreConfig<F
     }
 
     try {
-      config.onAttach?.({ store, target: newTarget, signal });
+      config.onAttach?.({
+        store,
+        target: newTarget as any,
+        signal,
+      });
     } catch (error) {
       handleError(error);
     }
@@ -156,12 +166,13 @@ export function createStore<Features extends AnyFeature[]>(config: StoreConfig<F
     return state.subscribe(callback);
   }
 
-  function meta(eventOrMeta: EventLike | RequestMetaInit): Store<Features> {
+  function meta(eventOrMeta: EventLike | RequestMetaInit): Store {
     currentMeta =
       'isTrusted' in eventOrMeta
         ? createRequestMetaFromEvent(eventOrMeta as EventLike)
         : createRequestMeta(eventOrMeta as RequestMetaInit);
-    return metaProxy as Store<Features>;
+
+    return metaProxy as Store;
   }
 
   function createInitialState(ctx: StateFactoryContext<Target>): State {
@@ -260,24 +271,29 @@ export function isStore(value: unknown): value is AnyStore {
 // Types
 // ----------------------------------------
 
-export interface StoreAPI<Target, Features extends AnyFeature<Target>[]> {
+export interface BaseStore<Target = unknown, State = UnknownState> {
+  [key: string]: unknown;
   readonly target: Target | null;
   readonly destroyed: boolean;
   readonly pending: Readonly<Record<string, PendingTask>>;
-  readonly state: UnionFeatureState<Features>;
+  readonly state: State;
   attach(target: Target): () => void;
   destroy(): void;
   subscribe(callback: StateChange): () => void;
-  meta(eventOrMeta: EventLike | RequestMetaInit): this;
+  meta(eventOrMeta: EventLike | RequestMetaInit): Store<Target, State>;
 }
 
-export type Store<Features extends AnyFeature[]> = StoreAPI<UnionFeatureTarget<Features>, Features> &
-  UnionFeatureState<Features>;
+export type Store<Target = unknown, State = UnknownState> = BaseStore<Target, State> & State;
 
-export type AnyStore<Target = any> = StoreAPI<Target, AnyFeature<Target>[]>;
+export type FeatureStore<Features extends AnyFeature[]> = Store<
+  UnionFeatureTarget<Features>,
+  UnionFeatureState<Features>
+>;
 
-export type InferStoreTarget<S extends AnyStore> = S extends StoreAPI<infer Target, any> ? Target : never;
+export type AnyStore<Target = any> = BaseStore<Target, object>;
 
-export type InferStoreFeatures<S extends AnyStore> = S extends StoreAPI<any, infer Features> ? Features : never;
+export type UnknownStore<Target = unknown> = Store<Target, UnknownState>;
 
-export type InferStoreState<S extends AnyStore> = UnionFeatureState<InferStoreFeatures<S>>;
+export type InferStoreTarget<S extends AnyStore> = S extends Store<infer T, any> ? T : never;
+
+export type InferStoreState<S extends AnyStore> = S extends Store<any, infer State> ? State : never;
diff --git a/packages/store/src/core/tests/feature-selector.test.ts b/packages/store/src/core/tests/feature-selector.test.ts
new file mode 100644
index 00000000..a708902a
--- /dev/null
+++ b/packages/store/src/core/tests/feature-selector.test.ts
@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { defineFeature } from '../feature';
+import { createFeatureSelector } from '../feature-selector';
+
+interface MockMedia {
+  volume: number;
+}
+
+describe('createFeatureSelector', () => {
+  const volumeFeature = defineFeature<MockMedia>()({
+    state: ({ task }) => ({
+      volume: 1,
+      muted: false,
+      setVolume(value: number) {
+        return task(({ target }) => {
+          target.volume = value;
+          return value;
+        });
+      },
+    }),
+  });
+
+  const playbackFeature = defineFeature<MockMedia>()({
+    state: () => ({
+      paused: true,
+      ended: false,
+    }),
+  });
+
+  it('selects feature state from store state', () => {
+    const selectVolume = createFeatureSelector(volumeFeature);
+    const state = { volume: 0.5, muted: true, setVolume: () => Promise.resolve(0.5) };
+
+    const selected = selectVolume(state);
+
+    expect(selected).toEqual({
+      volume: 0.5,
+      muted: true,
+      setVolume: state.setVolume,
+    });
+  });
+
+  it('returns undefined when feature is not configured', () => {
+    const selectVolume = createFeatureSelector(volumeFeature);
+    const state = { paused: true, ended: false }; // No volume keys
+
+    const selected = selectVolume(state);
+
+    expect(selected).toBeUndefined();
+  });
+
+  it('creates separate selectors for different features', () => {
+    const selectVolume = createFeatureSelector(volumeFeature);
+    const selectPlayback = createFeatureSelector(playbackFeature);
+    const state = {
+      volume: 0.75,
+      muted: false,
+      setVolume: () => Promise.resolve(0.75),
+      paused: false,
+      ended: false,
+    };
+
+    const volume = selectVolume(state);
+    const playback = selectPlayback(state);
+
+    expect(volume).toEqual({
+      volume: 0.75,
+      muted: false,
+      setVolume: state.setVolume,
+    });
+    expect(playback).toEqual({
+      paused: false,
+      ended: false,
+    });
+  });
+
+  it('returns stable references when state values are the same', () => {
+    const selectVolume = createFeatureSelector(volumeFeature);
+    const setVolume = () => Promise.resolve(1);
+    const state1 = { volume: 1, muted: false, setVolume };
+    const state2 = { volume: 1, muted: false, setVolume };
+
+    const selected1 = selectVolume(state1);
+    const selected2 = selectVolume(state2);
+
+    // Different object references (new object created each call)
+    expect(selected1).not.toBe(selected2);
+    // But structurally equal (for shallowEqual comparison)
+    expect(selected1).toEqual(selected2);
+  });
+});
diff --git a/packages/store/src/core/tests/integration/store.test.ts b/packages/store/src/core/tests/integration/store.test.ts
index e5ab977e..4a357f03 100644
--- a/packages/store/src/core/tests/integration/store.test.ts
+++ b/packages/store/src/core/tests/integration/store.test.ts
@@ -1,3 +1,4 @@
+import { noop } from '@videojs/utils/function';
 import { describe, expect, it } from 'vitest';
 
 import { createStore, defineFeature } from '../../index';
@@ -500,7 +501,7 @@ describe('sync actions', () => {
       }),
     });
 
-    const store = createStore({ features: [feature] });
+    const store = createStore({ features: [feature], onError: noop });
 
     await expect(store.doSomething()).rejects.toThrow('NO_TARGET');
   });
diff --git a/packages/store/src/core/tests/shallow-equal.test.ts b/packages/store/src/core/tests/shallow-equal.test.ts
new file mode 100644
index 00000000..9de49ef1
--- /dev/null
+++ b/packages/store/src/core/tests/shallow-equal.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { shallowEqual } from '../shallow-equal';
+
+describe('shallowEqual', () => {
+  it('returns true for identical primitives', () => {
+    expect(shallowEqual(1, 1)).toBe(true);
+    expect(shallowEqual('a', 'a')).toBe(true);
+    expect(shallowEqual(true, true)).toBe(true);
+    expect(shallowEqual(null, null)).toBe(true);
+    expect(shallowEqual(undefined, undefined)).toBe(true);
+  });
+
+  it('returns false for different primitives', () => {
+    expect(shallowEqual(1, 2)).toBe(false);
+    expect(shallowEqual('a', 'b')).toBe(false);
+    expect(shallowEqual(true, false)).toBe(false);
+    expect(shallowEqual(null, undefined)).toBe(false);
+  });
+
+  it('returns true for same reference', () => {
+    const obj = { a: 1 };
+    expect(shallowEqual(obj, obj)).toBe(true);
+  });
+
+  it('returns true for objects with same keys and values', () => {
+    expect(shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
+  });
+
+  it('returns false for objects with different values', () => {
+    expect(shallowEqual({ a: 1 }, { a: 2 })).toBe(false);
+  });
+
+  it('returns false for objects with different keys', () => {
+    expect(shallowEqual({ a: 1 }, { b: 1 })).toBe(false);
+    expect(shallowEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false);
+  });
+
+  it('returns false for nested objects with different references', () => {
+    expect(shallowEqual({ a: { b: 1 } }, { a: { b: 1 } })).toBe(false);
+  });
+
+  it('returns true for nested objects with same reference', () => {
+    const nested = { b: 1 };
+    expect(shallowEqual({ a: nested }, { a: nested })).toBe(true);
+  });
+
+  it('handles NaN correctly', () => {
+    expect(shallowEqual(NaN, NaN)).toBe(true);
+    expect(shallowEqual({ a: NaN }, { a: NaN })).toBe(true);
+  });
+
+  it('handles +0 and -0', () => {
+    expect(shallowEqual(0, -0)).toBe(false);
+    expect(shallowEqual({ a: 0 }, { a: -0 })).toBe(false);
+  });
+
+  it('returns false when comparing object to null', () => {
+    expect(shallowEqual({ a: 1 }, null)).toBe(false);
+    expect(shallowEqual(null, { a: 1 })).toBe(false);
+  });
+
+  it('returns false when comparing object to primitive', () => {
+    expect(shallowEqual({ a: 1 }, 1 as any)).toBe(false);
+    expect(shallowEqual(1 as any, { a: 1 })).toBe(false);
+  });
+});
diff --git a/packages/store/src/lit/create-store.ts b/packages/store/src/lit/create-store.ts
index a191f52a..92775e6f 100644
--- a/packages/store/src/lit/create-store.ts
+++ b/packages/store/src/lit/create-store.ts
@@ -4,8 +4,8 @@ import type { ReactiveControllerHost, ReactiveElement } from '@lit/reactive-elem
 import { noop } from '@videojs/utils/function';
 import type { Constructor } from '@videojs/utils/types';
 import type { StoreConfig } from '../core/config';
-import type { AnyFeature, UnionFeatureState } from '../core/feature';
-import type { Store } from '../core/store';
+import type { AnyFeature } from '../core/feature';
+import type { AnyStore, FeatureStore, InferStoreState } from '../core/store';
 import { createStore as createCoreStore } from '../core/store';
 import { createContainerMixin, createProviderMixin, createStoreMixin } from './mixins';
 import type { StoreConsumer, StoreProvider } from './types';
@@ -16,9 +16,9 @@ export interface CreateStoreConfig<Features extends AnyFeature[]> extends StoreC
 
 export type CreateStoreHost = ReactiveControllerHost & HTMLElement;
 
-export type StoreControllerValue<Features extends AnyFeature[]> = UnionFeatureState<Features>;
+export type StoreControllerValue<Store extends AnyStore> = InferStoreState<Store>;
 
-export interface CreateStoreResult<Features extends AnyFeature[]> {
+export interface CreateStoreResult<Store extends AnyStore> {
   /**
    * Combined mixin: provides store via context AND auto-attaches slotted media.
    *
@@ -27,7 +27,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * class MyPlayer extends StoreMixin(LitElement) {}
    * ```
    */
-  StoreMixin: <T extends Constructor<ReactiveElement>>(Base: T) => T & Constructor<StoreProvider<Features>>;
+  StoreMixin: <T extends Constructor<ReactiveElement>>(Base: T) => T & Constructor<StoreProvider<Store>>;
 
   /**
    * Mixin that provides store via context (no auto-attach).
@@ -39,7 +39,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * class MyProvider extends ProviderMixin(LitElement) {}
    * ```
    */
-  ProviderMixin: <T extends Constructor<ReactiveElement>>(Base: T) => T & Constructor<StoreProvider<Features>>;
+  ProviderMixin: <T extends Constructor<ReactiveElement>>(Base: T) => T & Constructor<StoreProvider<Store>>;
 
   /**
    * Mixin that auto-attaches slotted media elements (requires store from context).
@@ -51,7 +51,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * class MyControls extends ContainerMixin(LitElement) {}
    * ```
    */
-  ContainerMixin: <T extends Constructor<ReactiveElement>>(Base: T) => T & Constructor<StoreConsumer<Features>>;
+  ContainerMixin: <T extends Constructor<ReactiveElement>>(Base: T) => T & Constructor<StoreConsumer<Store>>;
 
   /**
    * Context for consuming store in controllers.
@@ -66,7 +66,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * }
    * ```
    */
-  context: Context<typeof contextKey, Store<Features>>;
+  context: Context<typeof contextKey, Store>;
 
   /**
    * Creates a store instance for imperative access.
@@ -79,7 +79,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * store.attach(videoElement);
    * ```
    */
-  create: () => Store<Features>;
+  create: () => Store;
 
   /**
    * Store controller bound to this store's context.
@@ -105,7 +105,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
   StoreController: new (
     host: CreateStoreHost
   ) => {
-    value: StoreControllerValue<Features>;
+    value: StoreControllerValue<Store>;
     hostConnected: () => void;
     hostDisconnected: () => void;
   };
@@ -145,8 +145,8 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
  */
 export function createStore<Features extends AnyFeature[]>(
   config: CreateStoreConfig<Features>
-): CreateStoreResult<Features> {
-  type ProvidedStore = Store<Features>;
+): CreateStoreResult<FeatureStore<Features>> {
+  type ProvidedStore = FeatureStore<Features>;
 
   const context = createContext<ProvidedStore, typeof contextKey>(contextKey);
 
@@ -154,9 +154,9 @@ export function createStore<Features extends AnyFeature[]>(
     return createCoreStore(config);
   }
 
-  const ProviderMixin = createProviderMixin<Features>(context, create);
-  const ContainerMixin = createContainerMixin<Features>(context);
-  const StoreMixin = createStoreMixin<Features>(context, create);
+  const ProviderMixin = createProviderMixin<ProvidedStore>(context, create);
+  const ContainerMixin = createContainerMixin<ProvidedStore>(context);
+  const StoreMixin = createStoreMixin<ProvidedStore>(context, create);
 
   class StoreController {
     readonly #host: CreateStoreHost;
@@ -175,7 +175,7 @@ export function createStore<Features extends AnyFeature[]>(
       host.addController(this);
     }
 
-    get value(): StoreControllerValue<Features> {
+    get value(): StoreControllerValue<ProvidedStore> {
       const store = this.#consumer.value;
 
       if (!store) {
@@ -183,7 +183,7 @@ export function createStore<Features extends AnyFeature[]>(
       }
 
       // In v2, state and actions are directly on the store object
-      return store as unknown as StoreControllerValue<Features>;
+      return store as unknown as StoreControllerValue<ProvidedStore>;
     }
 
     hostConnected(): void {
diff --git a/packages/store/src/lit/mixins/container-mixin.ts b/packages/store/src/lit/mixins/container-mixin.ts
index 84d661cb..8a6c7985 100644
--- a/packages/store/src/lit/mixins/container-mixin.ts
+++ b/packages/store/src/lit/mixins/container-mixin.ts
@@ -6,19 +6,12 @@ import { Disposer } from '@videojs/utils/events';
 import { noop } from '@videojs/utils/function';
 import { isNull } from '@videojs/utils/predicate';
 import type { Constructor, Mixin } from '@videojs/utils/types';
-import type { AnyFeature, UnionFeatureTarget } from '../../core/feature';
-import type { Store } from '../../core/store';
+import type { AnyStore, InferStoreTarget } from '../../core/store';
 import type { StoreConsumer } from '../types';
 
 /**
  * Creates a mixin that consumes a store from context and auto-attaches media elements.
  *
- * - Requests store from context (must have a provider ancestor)
- * - Observes slotted elements for `<video>` or `<audio>` in the default slot
- * - Falls back to light DOM children if no shadow root
- * - Calls `store.attach(mediaElement)` when found
- * - Cleans up on disconnect
- *
  * @example
  * ```ts
  * const { ContainerMixin } = createStore({ features: [playbackFeature] });
@@ -26,13 +19,11 @@ import type { StoreConsumer } from '../types';
  * class MyControls extends ContainerMixin(LitElement) {}
  * ```
  */
-export function createContainerMixin<Features extends AnyFeature[]>(
-  context: Context<unknown, Store<Features>>
-): Mixin<ReactiveElement, StoreConsumer<Features>> {
-  type ConsumedStore = Store<Features>;
-
+export function createContainerMixin<Store extends AnyStore>(
+  context: Context<unknown, Store>
+): Mixin<ReactiveElement, StoreConsumer<Store>> {
   return <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => {
-    class StoreAttachElement extends BaseClass implements StoreConsumer<Features> {
+    class StoreAttachElement extends BaseClass implements StoreConsumer<Store> {
       #disposer = new Disposer();
       #detach = noop;
 
@@ -42,7 +33,7 @@ export function createContainerMixin<Features extends AnyFeature[]>(
         subscribe: false,
       });
 
-      get store(): ConsumedStore | null {
+      get store(): Store | null {
         return this.#consumer.value ?? null;
       }
 
@@ -69,7 +60,6 @@ export function createContainerMixin<Features extends AnyFeature[]>(
 
         if (isNull(store)) return;
 
-        // Check if element is media, or search inside for nested media
         const findMedia = (el: Element): HTMLMediaElement | null =>
           isHTMLMediaElement(el) ? el : el.querySelector('video, audio');
 
@@ -79,7 +69,7 @@ export function createContainerMixin<Features extends AnyFeature[]>(
 
         if (store.target !== media) {
           this.#detach();
-          this.#detach = store.attach(media as UnionFeatureTarget<Features>);
+          this.#detach = store.attach(media as InferStoreTarget<Store>);
         }
       }
     }
diff --git a/packages/store/src/lit/mixins/provider-mixin.ts b/packages/store/src/lit/mixins/provider-mixin.ts
index ec269c45..b730568b 100644
--- a/packages/store/src/lit/mixins/provider-mixin.ts
+++ b/packages/store/src/lit/mixins/provider-mixin.ts
@@ -3,18 +3,12 @@ import { ContextProvider } from '@lit/context';
 import type { ReactiveElement } from '@lit/reactive-element';
 import { isNull } from '@videojs/utils/predicate';
 import type { Constructor } from '@videojs/utils/types';
-import type { AnyFeature } from '../../core/feature';
-import type { Store } from '../../core/store';
+import type { AnyStore } from '../../core/store';
 import type { StoreProvider } from '../types';
 
 /**
  * Creates a mixin that provides a store via context.
  *
- * - Creates a store instance on first access
- * - Provides the store to descendants via Lit Context Protocol
- * - Allows store replacement via setter (notifies all consumers)
- * - Destroys the store on disconnect (if not externally provided)
- *
  * @example
  * ```ts
  * const { ProviderMixin } = createStore({
@@ -28,15 +22,13 @@ import type { StoreProvider } from '../types';
  * }
  * ```
  */
-export function createProviderMixin<Features extends AnyFeature[]>(
-  context: Context<unknown, Store<Features>>,
-  factory: () => Store<Features>
-): <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => Base & Constructor<StoreProvider<Features>> {
-  type ProvidedStore = Store<Features>;
-
+export function createProviderMixin<Store extends AnyStore>(
+  context: Context<unknown, Store>,
+  factory: () => Store
+): <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => Base & Constructor<StoreProvider<Store>> {
   return <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => {
-    class StoreProviderElement extends BaseClass implements StoreProvider<Features> {
-      #store: ProvidedStore | null = null;
+    class StoreProviderElement extends BaseClass implements StoreProvider<Store> {
+      #store: Store | null = null;
       #isOwner = false;
 
       #provider = new ContextProvider(this, {
@@ -44,7 +36,7 @@ export function createProviderMixin<Features extends AnyFeature[]>(
         initialValue: this.store,
       });
 
-      get store(): ProvidedStore {
+      get store(): Store {
         if (isNull(this.#store)) {
           this.#store = factory();
           this.#isOwner = true;
@@ -53,7 +45,7 @@ export function createProviderMixin<Features extends AnyFeature[]>(
         return this.#store;
       }
 
-      set store(newStore: ProvidedStore) {
+      set store(newStore: Store) {
         const wasOwner = this.#isOwner;
         const oldStore = this.#store;
 
diff --git a/packages/store/src/lit/mixins/store-mixin.ts b/packages/store/src/lit/mixins/store-mixin.ts
index a6090f72..8f2dd1c3 100644
--- a/packages/store/src/lit/mixins/store-mixin.ts
+++ b/packages/store/src/lit/mixins/store-mixin.ts
@@ -1,8 +1,7 @@
 import type { Context } from '@lit/context';
 import type { ReactiveElement } from '@lit/reactive-element';
 import type { Constructor, Mixin } from '@videojs/utils/types';
-import type { AnyFeature } from '../../core/feature';
-import type { Store } from '../../core/store';
+import type { AnyStore } from '../../core/store';
 import type { StoreProvider } from '../types';
 
 import { createContainerMixin } from './container-mixin';
@@ -25,12 +24,12 @@ import { createProviderMixin } from './provider-mixin';
  * }
  * ```
  */
-export function createStoreMixin<Features extends AnyFeature[]>(
-  context: Context<unknown, Store<Features>>,
-  factory: () => Store<Features>
-): Mixin<ReactiveElement, StoreProvider<Features>> {
-  const ProviderMixin = createProviderMixin<Features>(context, factory);
-  const ContainerMixin = createContainerMixin<Features>(context);
+export function createStoreMixin<Store extends AnyStore>(
+  context: Context<unknown, Store>,
+  factory: () => Store
+): Mixin<ReactiveElement, StoreProvider<Store>> {
+  const ProviderMixin = createProviderMixin<Store>(context, factory);
+  const ContainerMixin = createContainerMixin<Store>(context);
 
   return <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => {
     // ProviderMixin wraps AttachMixin so during connectedCallback:
diff --git a/packages/store/src/lit/tests/test-utils.ts b/packages/store/src/lit/tests/test-utils.ts
index 54f7e461..0d1bed74 100644
--- a/packages/store/src/lit/tests/test-utils.ts
+++ b/packages/store/src/lit/tests/test-utils.ts
@@ -2,7 +2,7 @@ import { ReactiveElement } from '@lit/reactive-element';
 import { noop } from '@videojs/utils/function';
 import { afterEach } from 'vitest';
 import { defineFeature } from '../../core/feature';
-import type { Store } from '../../core/store';
+import type { FeatureStore } from '../../core/store';
 import { createStore as createCoreStore } from '../../core/store';
 import { createStore as createLitStore } from '../create-store';
 
@@ -113,20 +113,9 @@ export const customKeyFeature = defineFeature<MockMedia>()({
 type TestFeature = typeof audioFeature;
 type CustomKeyFeature = typeof customKeyFeature;
 
-type TestStore = Store<[TestFeature]> & {
-  volume: number;
-  muted: boolean;
-  setVolume: (volume: number) => Promise<number>;
-  setMuted: (muted: boolean) => Promise<boolean>;
-  slowSetVolume: (volume: number) => Promise<number>;
-};
-
-type CustomKeyStore = Store<[CustomKeyFeature]> & {
-  volume: number;
-  muted: boolean;
-  adjustVolume: (volume: number) => Promise<number>;
-  toggleMute: (muted: boolean) => Promise<boolean>;
-};
+// FeatureStore already includes state intersection, no need to repeat
+type TestStore = FeatureStore<[TestFeature]>;
+type CustomKeyStore = FeatureStore<[CustomKeyFeature]>;
 
 // For controller tests - creates core store with attached target
 export function createCoreTestStore(): { store: TestStore; target: MockMedia } {
diff --git a/packages/store/src/lit/types.ts b/packages/store/src/lit/types.ts
index 23ca9e9f..77bc9443 100644
--- a/packages/store/src/lit/types.ts
+++ b/packages/store/src/lit/types.ts
@@ -1,10 +1,9 @@
-import type { AnyFeature } from '../core/feature';
-import type { Store } from '../core/store';
+import type { AnyStore } from '../core/store';
 
-export interface StoreProvider<Features extends AnyFeature[]> {
-  store: Store<Features>;
+export interface StoreProvider<Store extends AnyStore> {
+  store: Store;
 }
 
-export interface StoreConsumer<Features extends AnyFeature[]> {
-  readonly store: Store<Features> | null;
+export interface StoreConsumer<Store extends AnyStore> {
+  readonly store: Store | null;
 }
diff --git a/packages/store/src/react/create-store.tsx b/packages/store/src/react/create-store.tsx
index e4df1b1a..928262a8 100644
--- a/packages/store/src/react/create-store.tsx
+++ b/packages/store/src/react/create-store.tsx
@@ -2,8 +2,8 @@ import { isUndefined } from '@videojs/utils/predicate';
 import type { FC, ReactNode } from 'react';
 import { useEffect, useState } from 'react';
 import type { StoreConfig } from '../core/config';
-import type { AnyFeature, UnionFeatureState } from '../core/feature';
-import type { Store } from '../core/store';
+import type { AnyFeature } from '../core/feature';
+import type { AnyStore, FeatureStore } from '../core/store';
 import { createStore as createCoreStore } from '../core/store';
 import { StoreContextProvider, useStoreContext } from './context';
 import { useStore as useStoreBase } from './hooks/use-store';
@@ -12,28 +12,27 @@ export interface CreateStoreConfig<Features extends AnyFeature[]> extends StoreC
   displayName?: string;
 }
 
-export interface ProviderProps<Features extends AnyFeature[]> {
+export interface ProviderProps<S extends AnyStore> {
   children: ReactNode;
-  store?: Store<Features>;
+  store?: S;
 }
 
-export type UseStoreResult<Features extends AnyFeature[]> = UnionFeatureState<Features>;
-
-export interface CreateStoreResult<Features extends AnyFeature[]> {
+export interface CreateStoreResult<S extends AnyStore> {
   /** Provider component that creates and manages the store lifecycle. */
-  Provider: FC<ProviderProps<Features>>;
+  Provider: FC<ProviderProps<S>>;
 
   /**
-   * Subscribe to store state and access requests.
-   * Returns state with request map, re-renders when state changes.
+   * Access store state and actions.
+   * Returns the store without subscribing to changes.
+   * Use selectors via `useSelector` for reactive updates.
    */
-  useStore: () => UseStoreResult<Features>;
+  useStore: () => S;
 
   /**
    * Creates a new store instance.
    * Useful for imperative access or creating a store before render.
    */
-  create: () => Store<Features>;
+  create: () => S;
 }
 
 // ----------------------------------------
@@ -55,10 +54,10 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
  */
 export function createStore<Features extends AnyFeature[]>(
   config: CreateStoreConfig<Features>
-): CreateStoreResult<Features> {
-  type StoreType = Store<Features>;
+): CreateStoreResult<FeatureStore<Features>> {
+  type Store = FeatureStore<Features>;
 
-  function create(): StoreType {
+  function create(): Store {
     return createCoreStore(config);
   }
 
@@ -68,8 +67,8 @@ export function createStore<Features extends AnyFeature[]>(
    * If `store` prop is provided, uses that store (no cleanup on unmount).
    * Otherwise, creates a new store and destroys it on unmount.
    */
-  function Provider({ children, store: providedStore }: ProviderProps<Features>): ReactNode {
-    const [store] = useState<StoreType>(() => {
+  function Provider({ children, store: providedStore }: ProviderProps<Store>): ReactNode {
+    const [store] = useState<Store>(() => {
       if (!isUndefined(providedStore)) {
         return providedStore;
       }
@@ -95,9 +94,9 @@ export function createStore<Features extends AnyFeature[]>(
     Provider.displayName = `${config.displayName}.Provider`;
   }
 
-  function useStore(): UseStoreResult<Features> {
+  function useStore(): Store {
     const store = useStoreContext();
-    return useStoreBase(store) as UseStoreResult<Features>;
+    return useStoreBase(store) as Store;
   }
 
   return {
diff --git a/packages/store/src/react/hooks/index.ts b/packages/store/src/react/hooks/index.ts
index 1411677f..64df4ad5 100644
--- a/packages/store/src/react/hooks/index.ts
+++ b/packages/store/src/react/hooks/index.ts
@@ -1 +1,2 @@
+export { useSelector } from './use-selector';
 export { useStore } from './use-store';
diff --git a/packages/store/src/react/hooks/tests/use-selector.test.tsx b/packages/store/src/react/hooks/tests/use-selector.test.tsx
new file mode 100644
index 00000000..31934967
--- /dev/null
+++ b/packages/store/src/react/hooks/tests/use-selector.test.tsx
@@ -0,0 +1,69 @@
+import { cleanup, render, screen } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { useSelector } from '../use-selector';
+
+afterEach(cleanup);
+
+describe('useSelector', () => {
+  it('returns selected state from getSnapshot', () => {
+    const state = { volume: 0.5, muted: false };
+    const subscribe = vi.fn((_cb: () => void) => () => {});
+    const getSnapshot = () => state;
+    const selector = (s: typeof state) => s.volume;
+
+    function TestComponent() {
+      const volume = useSelector(subscribe, getSnapshot, selector);
+      return <div data-testid="volume">{volume}</div>;
+    }
+
+    render(<TestComponent />);
+    expect(screen.getByTestId('volume').textContent).toBe('0.5');
+  });
+
+  it('uses shallowEqual by default for object selectors', () => {
+    const state = { volume: 0.5, muted: false };
+    let subscriber: (() => void) | undefined;
+
+    const subscribe = (cb: () => void) => {
+      subscriber = cb;
+      return () => {
+        subscriber = undefined;
+      };
+    };
+
+    const getSnapshot = () => state;
+    const selector = (s: typeof state) => ({ vol: s.volume });
+
+    function TestComponent() {
+      const selected = useSelector(subscribe, getSnapshot, selector);
+      return <div data-testid="vol">{selected.vol}</div>;
+    }
+
+    const { rerender } = render(<TestComponent />);
+
+    // Trigger re-render with same state (selector returns new object but shallowEqual should match)
+    subscriber?.();
+    rerender(<TestComponent />);
+
+    // shallowEqual should prevent unnecessary updates when objects are structurally equal
+    expect(screen.getByTestId('vol').textContent).toBe('0.5');
+  });
+
+  it('allows custom equality function', () => {
+    const state = { items: [1, 2, 3] };
+    const subscribe = vi.fn((_cb: () => void) => () => {});
+    const getSnapshot = () => state;
+    const selector = (s: typeof state) => s.items;
+
+    // Custom equality that always returns true
+    const alwaysEqual = () => true;
+
+    function TestComponent() {
+      const items = useSelector(subscribe, getSnapshot, selector, alwaysEqual);
+      return <div data-testid="count">{items.length}</div>;
+    }
+
+    render(<TestComponent />);
+    expect(screen.getByTestId('count').textContent).toBe('3');
+  });
+});
diff --git a/packages/store/src/react/hooks/tests/use-store.test.tsx b/packages/store/src/react/hooks/tests/use-store.test.tsx
index c7d6efa3..a94c5a6f 100644
--- a/packages/store/src/react/hooks/tests/use-store.test.tsx
+++ b/packages/store/src/react/hooks/tests/use-store.test.tsx
@@ -12,27 +12,80 @@ interface AudioState {
 }
 
 describe('useStore', () => {
-  it('returns state and action functions spread together', () => {
-    const { store } = createTestStore();
+  describe('without selector', () => {
+    it('returns state and action functions', () => {
+      const { store } = createTestStore();
 
-    const { result } = renderHook(() => useStore(store) as AudioState);
+      const { result } = renderHook(() => useStore(store) as AudioState);
 
-    expect(result.current.volume).toBe(1);
-    expect(result.current.muted).toBe(false);
-    expect(typeof result.current.setVolume).toBe('function');
-  });
-
-  it('updates when state changes', async () => {
-    const { store } = createTestStore();
-
-    const { result } = renderHook(() => useStore(store) as AudioState);
-
-    expect(result.current.volume).toBe(1);
-
-    await act(async () => {
-      await result.current.setVolume(0.5);
+      expect(result.current.volume).toBe(1);
+      expect(result.current.muted).toBe(false);
+      expect(typeof result.current.setVolume).toBe('function');
     });
 
-    expect(result.current.volume).toBe(0.5);
+    it('does not re-render on state change', async () => {
+      const { store } = createTestStore();
+      let renderCount = 0;
+
+      const { result } = renderHook(() => {
+        renderCount++;
+        return useStore(store) as AudioState;
+      });
+
+      expect(renderCount).toBe(1);
+      expect(result.current.volume).toBe(1);
+
+      await act(async () => {
+        await result.current.setVolume(0.5);
+      });
+
+      // Should NOT have re-rendered (equality always returns true)
+      expect(renderCount).toBe(1);
+      // But state DID change - just not reflected in result.current
+      expect(store.state.volume).toBe(0.5);
+    });
+  });
+
+  describe('with selector', () => {
+    it('re-renders when selected state changes', async () => {
+      const { store } = createTestStore();
+      let renderCount = 0;
+
+      const { result } = renderHook(() => {
+        renderCount++;
+        return useStore(store, (s: AudioState) => s.volume);
+      });
+
+      expect(renderCount).toBe(1);
+      expect(result.current).toBe(1);
+
+      await act(async () => {
+        await (store as unknown as AudioState).setVolume(0.5);
+      });
+
+      // Should have re-rendered
+      expect(renderCount).toBe(2);
+      expect(result.current).toBe(0.5);
+    });
+
+    it('does not re-render when unrelated state changes', async () => {
+      const { store } = createTestStore();
+      let renderCount = 0;
+
+      const { result } = renderHook(() => {
+        renderCount++;
+        return useStore(store, (s: AudioState) => s.volume);
+      });
+
+      expect(renderCount).toBe(1);
+
+      await act(async () => {
+        await (store as unknown as AudioState).setMuted(true);
+      });
+
+      // Should NOT re-render since volume didn't change
+      expect(renderCount).toBe(1);
+      expect(result.current).toBe(1);
+    });
   });
 });
diff --git a/packages/store/src/react/hooks/use-selector.ts b/packages/store/src/react/hooks/use-selector.ts
new file mode 100644
index 00000000..9a082a8d
--- /dev/null
+++ b/packages/store/src/react/hooks/use-selector.ts
@@ -0,0 +1,30 @@
+import { useRef, useSyncExternalStore } from 'react';
+import { shallowEqual } from '../../core/shallow-equal';
+
+export type Selector<S, R> = (state: S) => R;
+
+export type Comparator<T> = (a: T, b: T) => boolean;
+
+/** Subscribe to derived state with customizable equality check. */
+export function useSelector<S, R>(
+  subscribe: (cb: () => void) => () => void,
+  getSnapshot: () => S,
+  selector: Selector<S, R>,
+  isEqual: Comparator<R> = shallowEqual
+): R {
+  const cache = useRef<R | undefined>(undefined);
+
+  const getSelectedSnapshot = () => {
+    const next = selector(getSnapshot());
+
+    if (cache.current !== undefined && isEqual(cache.current, next)) {
+      return cache.current;
+    }
+
+    cache.current = next;
+
+    return next;
+  };
+
+  return useSyncExternalStore(subscribe, getSelectedSnapshot, getSelectedSnapshot);
+}
diff --git a/packages/store/src/react/hooks/use-store.ts b/packages/store/src/react/hooks/use-store.ts
index ea7baa08..5e751396 100644
--- a/packages/store/src/react/hooks/use-store.ts
+++ b/packages/store/src/react/hooks/use-store.ts
@@ -1,38 +1,45 @@
-import { useSyncExternalStore } from 'react';
+import { noop } from '@videojs/utils/function';
 import type { AnyStore, InferStoreState } from '../../core/store';
+import { type Comparator, type Selector, useSelector } from './use-selector';
 
-export type UseStoreResult<S extends AnyStore> = InferStoreState<S>;
+const identity = (s: any) => s,
+  noopSubscribe = () => noop;
 
 /**
- * Subscribe to store state changes.
+ * Access store state and actions.
  *
- * Returns state and action functions, re-renders when state changes.
+ * Without selector: Returns the store, does NOT subscribe to changes.
+ * With selector: Returns selected state, re-renders when selected state changes (shallowEqual).
  *
  * @example
  * ```tsx
- * function VolumeControl() {
- *   const { volume, setVolume } = useStore(store);
- *   return (
- *     <input
- *       type="range"
- *       value={volume}
- *       onChange={(e) => setVolume(+e.target.value)}
- *     />
- *   );
+ * // Store access (no subscription) - access actions, subscribe without re-render
+ * function Controls() {
+ *   const { setVolume } = useStore(store);
+ * }
+ *
+ * // Selector-based subscription - re-renders when paused changes
+ * function PlayButton() {
+ *   const paused = useStore(store, (s) => s.paused);
+ *   return <button>{paused ? 'Play' : 'Pause'}</button>;
  * }
  * ```
  */
-export function useStore<S extends AnyStore>(store: S): UseStoreResult<S> {
-  useSyncExternalStore(
-    (cb) => store.subscribe(cb),
-    () => store.state,
-    () => store.state
-  );
+export function useStore<S extends AnyStore>(store: S): S;
 
-  // In v2, state and actions are directly on the store object
-  return store as unknown as UseStoreResult<S>;
+export function useStore<S extends AnyStore, R>(
+  store: S,
+  selector: Selector<InferStoreState<S>, R>,
+  isEqual?: Comparator<R>
+): R;
+
+export function useStore(store: AnyStore, selector?: Selector<any, any>, isEqual?: Comparator<any>) {
+  const subscribe = selector ? (cb: () => void) => store.subscribe(cb) : noopSubscribe,
+    getSnapshot = selector ? () => store.state : () => store;
+
+  return useSelector(subscribe, getSnapshot, selector ?? identity, isEqual);
 }
 
 export namespace useStore {
-  export type Result<S extends AnyStore> = UseStoreResult<S>;
+  export type Result<S extends AnyStore> = S;
 }
diff --git a/packages/store/src/react/tests/create-store.test.tsx b/packages/store/src/react/tests/create-store.test.tsx
index f9675dbe..4e940893 100644
--- a/packages/store/src/react/tests/create-store.test.tsx
+++ b/packages/store/src/react/tests/create-store.test.tsx
@@ -115,18 +115,26 @@ describe('createStore', () => {
       expect(typeof result.current.setVolume).toBe('function');
     });
 
-    it('updates when state changes', async () => {
+    it('does not re-render on state change (no subscription)', async () => {
       const { Provider, useStore, create } = createStore({
         features: [audioFeature],
       });
       const store = create();
       const target = new MockMedia();
       store.attach(target);
+      let renderCount = 0;
 
-      const { result } = renderHook(() => useStore() as AudioState, {
-        wrapper: ({ children }: { children: ReactNode }) => <Provider store={store}>{children}</Provider>,
-      });
+      const { result } = renderHook(
+        () => {
+          renderCount++;
+          return useStore() as AudioState;
+        },
+        {
+          wrapper: ({ children }: { children: ReactNode }) => <Provider store={store}>{children}</Provider>,
+        }
+      );
 
+      expect(renderCount).toBe(1);
       expect(result.current.volume).toBe(1);
 
       await act(async () => {
@@ -134,7 +142,10 @@ describe('createStore', () => {
         target.dispatchEvent(new Event('volumechange'));
       });
 
-      expect(result.current.volume).toBe(0.5);
+      // Should NOT have re-rendered
+      expect(renderCount).toBe(1);
+      // But store state DID change
+      expect(store.state.volume).toBe(0.5);
     });
   });
 });
diff --git a/packages/utils/src/object/pick.ts b/packages/utils/src/object/pick.ts
index 83cd73ec..b69107f6 100644
--- a/packages/utils/src/object/pick.ts
+++ b/packages/utils/src/object/pick.ts
@@ -9,9 +9,7 @@ export function pick<T extends Record<string, unknown>, K extends keyof T>(obj:
   const result = {} as Pick<T, K>;
 
   for (const key of keys) {
-    if (Object.hasOwn(obj, key)) {
-      result[key] = obj[key];
-    }
+    result[key] = obj[key];
   }
 
   return result;
diff --git a/packages/utils/src/types/types.ts b/packages/utils/src/types/types.ts
index 3baac0ff..a1d15798 100644
--- a/packages/utils/src/types/types.ts
+++ b/packages/utils/src/types/types.ts
@@ -14,5 +14,4 @@ export type Falsy<T> = T | false | null | undefined;
 
 export type EnsureFunction<T> = T extends (...args: any[]) => any ? T : never;
 
-/** Flatten intersection types for better IDE display. */
-export type Simplify<T> = T extends (...args: any[]) => any ? T : { [K in keyof T]: T[K] } & {};
+export type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};