diff --git a/.claude/skills/component/references/lit.md b/.claude/skills/component/references/lit.md
index 227addef..a5093156 100644
--- a/.claude/skills/component/references/lit.md
+++ b/.claude/skills/component/references/lit.md
@@ -48,8 +48,7 @@ All store-related controllers live in `@videojs/store/lit`. See that package for
 
 ```ts
 class MyElement extends ReactiveElement {
-  #state = new SnapshotController(this, store.state);
-  #play = new RequestController(this, context, 'play');
+  #store = new StoreController(this, context);
 }
 ```
 
@@ -71,10 +70,10 @@ Internal utility that resolves a store from either a direct instance or context.
 
 ```ts
 // Direct store — value available immediately
-const state = new SnapshotController(this, store.state);
+const store = new StoreController(this, store);
 
-// Context — value available after context resolves via StateController from createStore
-const state = new StateController(this);
+// Context — value available after context resolves
+const store = new StoreController(this, context);
 ```
 
 Controllers handle both cases transparently. The `StoreAccessor`:
@@ -90,7 +89,7 @@ Controllers handle both cases transparently. The `StoreAccessor`:
 Always export an explicit host type for controllers and mixins:
 
 ```ts
-export type SnapshotControllerHost = ReactiveControllerHost & HTMLElement;
+export type StoreControllerHost = ReactiveControllerHost & HTMLElement;
 export type ProviderMixinHost = ReactiveElement & EventTarget;
 ```
 
@@ -104,16 +103,29 @@ export type ProviderMixinHost = ReactiveElement & EventTarget;
 
 Mixins are for **store provision only**, not behavior. Behavior goes in controllers.
 
-### createStoreProviderMixin
+### Store Mixins
 
-Creates a mixin that provides a store via context:
+`createStore()` returns mixins for different use cases:
 
 ```ts
-const { StoreProviderMixin } = createStore({ features: [playbackFeature] });
+const { StoreMixin, ProviderMixin, ContainerMixin } = createStore({
+  features: [playbackFeature],
+});
 
-class MyPlayer extends StoreProviderMixin(ReactiveElement) {
+// StoreMixin: provides store AND auto-attaches slotted media
+class MyPlayer extends StoreMixin(ReactiveElement) {
+  // Store provided to all descendants, media auto-attached
+}
+
+// ProviderMixin: provides store only (no auto-attach)
+class MyProvider extends ProviderMixin(ReactiveElement) {
   // Store provided to all descendants
 }
+
+// ContainerMixin: consumes store from context, auto-attaches media
+class MyControls extends ContainerMixin(ReactiveElement) {
+  // Inherits store from parent provider
+}
 ```
 
 - Creates store on first access (lazy)
diff --git a/.claude/skills/docs/templates/readme.md b/.claude/skills/docs/templates/readme.md
index 4732c54f..fa45ac35 100644
--- a/.claude/skills/docs/templates/readme.md
+++ b/.claude/skills/docs/templates/readme.md
@@ -152,21 +152,20 @@ Explanation.
 Core concepts:
 
 - Target
-- Features
+- Features (defineFeature, state factory)
 - Feature Type Inference
-- Requests
-- Request Metadata
-- Store
-- Request Configuration (Keys, Cancels, Guards)
+- Actions (task helper, sync mutations)
+- Action Metadata (store.meta())
+- Store (flat access, pending tasks)
+- Task Configuration (Keys, Modes, Cancels)
 - Error Handling
-- Queue
 
 ### @videojs/store/lit
 
 Core concepts:
 
-- Controllers (SnapshotController, RequestController, TasksController)
-- Mixins (StoreMixin, StoreProviderMixin, StoreAttachMixin)
+- Controllers (StoreController, SubscriptionController)
+- Mixins (StoreMixin, ProviderMixin, ContainerMixin)
 - createStore factory pattern
 - Context API
 
@@ -217,14 +216,14 @@ Always include at top:
 ```markdown
 npm install @videojs/store
 
-import { createFeature, createStore } from '@videojs/store';
+import { createStore } from '@videojs/store';
 
 const store = createStore({
 features: [playbackFeature, volumeFeature],
 });
 
 store.attach(videoElement);
-await store.request.play();
+await store.play();
 ```
 
 ### "How It's Different" Table
@@ -243,10 +242,10 @@ Use when comparing to alternatives:
 Always show type inference for TypeScript users:
 
 ```ts
-import type { InferFeatureRequests, InferFeatureState } from '@videojs/store';
+import type { InferFeatureState } from '@videojs/store';
 
 type VolumeState = InferFeatureState<typeof volumeFeature>;
-type VolumeRequests = InferFeatureRequests<typeof volumeFeature>;
+// { volume: number; muted: boolean; changeVolume: ...; toggleMute: ... }
 ```
 
 ### Links Footer
diff --git a/packages/core/src/dom/store/features/buffer.ts b/packages/core/src/dom/store/features/buffer.ts
index a50922aa..bed47e7f 100644
--- a/packages/core/src/dom/store/features/buffer.ts
+++ b/packages/core/src/dom/store/features/buffer.ts
@@ -1,20 +1,15 @@
-import type { InferFeatureRequests, InferFeatureState } from '@videojs/store';
+import type { InferFeatureState } from '@videojs/store';
 
-import { createFeature } from '@videojs/store';
+import { defineFeature } from '@videojs/store';
 import { listen, serializeTimeRanges } from '@videojs/utils/dom';
 
-/**
- * Buffer feature for HTMLMediaElement.
- *
- * Tracks buffered and seekable time ranges. Read-only (no requests).
- */
-export const bufferFeature = createFeature<HTMLMediaElement>()({
-  initialState: {
+export const bufferFeature = defineFeature<HTMLMediaElement>()({
+  state: () => ({
     /** Buffered time ranges as [start, end] tuples. */
     buffered: [] as [number, number][],
     /** Seekable time ranges as [start, end] tuples. */
     seekable: [] as [number, number][],
-  },
+  }),
 
   getSnapshot: ({ target }) => ({
     buffered: serializeTimeRanges(target.buffered),
@@ -25,10 +20,6 @@ export const bufferFeature = createFeature<HTMLMediaElement>()({
     listen(target, 'progress', update, { signal });
     listen(target, 'emptied', update, { signal });
   },
-
-  request: {},
 });
 
 export type BufferState = InferFeatureState<typeof bufferFeature>;
-
-export type BufferRequests = InferFeatureRequests<typeof bufferFeature>;
diff --git a/packages/core/src/dom/store/features/playback.ts b/packages/core/src/dom/store/features/playback.ts
index d3619d3c..48b9124e 100644
--- a/packages/core/src/dom/store/features/playback.ts
+++ b/packages/core/src/dom/store/features/playback.ts
@@ -1,15 +1,10 @@
-import type { InferFeatureRequests, InferFeatureState } from '@videojs/store';
+import type { InferFeatureState } from '@videojs/store';
 
-import { createFeature } from '@videojs/store';
+import { defineFeature } from '@videojs/store';
 import { listen } from '@videojs/utils/dom';
 
-/**
- * Playback feature for HTMLMediaElement.
- *
- * Tracks core playback state and provides play/pause control.
- */
-export const playbackFeature = createFeature<HTMLMediaElement>()({
-  initialState: {
+export const playbackFeature = defineFeature<HTMLMediaElement>()({
+  state: ({ task }) => ({
     /** Whether playback is paused. */
     paused: true,
     /** Whether playback has reached the end. */
@@ -18,7 +13,28 @@ export const playbackFeature = createFeature<HTMLMediaElement>()({
     started: false,
     /** Whether playback is stalled waiting for data. */
     waiting: false,
-  },
+
+    /** Start playback. Returns when playback begins. */
+    play() {
+      return task({
+        key: 'playback',
+        mode: 'shared',
+        async handler({ target }) {
+          await target.play();
+        },
+      });
+    },
+
+    /** Pause playback immediately. */
+    pause() {
+      return task({
+        key: 'playback',
+        handler({ target }) {
+          target.pause();
+        },
+      });
+    },
+  }),
 
   getSnapshot: ({ target }) => ({
     paused: target.paused,
@@ -34,20 +50,6 @@ export const playbackFeature = createFeature<HTMLMediaElement>()({
     listen(target, 'playing', update, { signal });
     listen(target, 'waiting', update, { signal });
   },
-
-  request: {
-    /** Start playback. Returns when playback begins. */
-    play: async (_, { target }) => {
-      await target.play();
-    },
-
-    /** Pause playback immediately. */
-    pause: (_, { target }) => {
-      target.pause();
-    },
-  },
 });
 
 export type PlaybackState = InferFeatureState<typeof playbackFeature>;
-
-export type PlaybackRequests = InferFeatureRequests<typeof playbackFeature>;
diff --git a/packages/core/src/dom/store/features/source.ts b/packages/core/src/dom/store/features/source.ts
index a1f9fa03..faaeba1b 100644
--- a/packages/core/src/dom/store/features/source.ts
+++ b/packages/core/src/dom/store/features/source.ts
@@ -1,20 +1,27 @@
-import type { InferFeatureRequests, InferFeatureState } from '@videojs/store';
+import type { InferFeatureState } from '@videojs/store';
 
-import { createFeature } from '@videojs/store';
+import { CANCEL_ALL, defineFeature } from '@videojs/store';
 import { listen } from '@videojs/utils/dom';
 
-/**
- * Source feature for HTMLMediaElement.
- *
- * Tracks current source and loading state, provides source change control.
- */
-export const sourceFeature = createFeature<HTMLMediaElement>()({
-  initialState: {
+export const sourceFeature = defineFeature<HTMLMediaElement>()({
+  state: ({ task }) => ({
     /** Current media source URL (null if none). */
     source: null as string | null,
     /** Whether enough data is loaded to begin playback. */
     canPlay: false,
-  },
+    /** Load a new media source. Cancels all pending operations. Returns the new source URL. */
+    loadSource(src: string) {
+      return task({
+        key: 'source',
+        cancels: [CANCEL_ALL],
+        handler({ target }) {
+          target.src = src;
+          target.load();
+          return src;
+        },
+      });
+    },
+  }),
 
   getSnapshot: ({ target }) => ({
     source: target.currentSrc || target.src || null,
@@ -27,17 +34,6 @@ export const sourceFeature = createFeature<HTMLMediaElement>()({
     listen(target, 'loadstart', update, { signal });
     listen(target, 'emptied', update, { signal });
   },
-
-  request: {
-    /** Change media source and begin loading. Returns the new source URL. */
-    changeSource: (src: string, { target }) => {
-      target.src = src;
-      target.load();
-      return src;
-    },
-  },
 });
 
 export type SourceState = InferFeatureState<typeof sourceFeature>;
-
-export type SourceRequests = InferFeatureRequests<typeof sourceFeature>;
diff --git a/packages/core/src/dom/store/features/tests/buffer.test.ts b/packages/core/src/dom/store/features/tests/buffer.test.ts
index 5fad047a..4f87821a 100644
--- a/packages/core/src/dom/store/features/tests/buffer.test.ts
+++ b/packages/core/src/dom/store/features/tests/buffer.test.ts
@@ -3,23 +3,6 @@ import { describe, expect, it, vi } from 'vitest';
 import { bufferFeature } from '../buffer';
 
 describe('bufferFeature', () => {
-  describe('feature structure', () => {
-    it('has unique id symbol', () => {
-      expect(bufferFeature.id).toBeTypeOf('symbol');
-    });
-
-    it('has correct initial state', () => {
-      expect(bufferFeature.initialState).toEqual({
-        buffered: [],
-        seekable: [],
-      });
-    });
-
-    it('has no request handlers', () => {
-      expect(Object.keys(bufferFeature.request)).toHaveLength(0);
-    });
-  });
-
   describe('getSnapshot', () => {
     it('captures buffered and seekable ranges from video element', () => {
       const video = createMockVideo({
@@ -29,7 +12,8 @@ describe('bufferFeature', () => {
 
       const snapshot = bufferFeature.getSnapshot({
         target: video,
-        initialState: bufferFeature.initialState,
+        get: () => ({ buffered: [], seekable: [] }),
+        initialState: { buffered: [], seekable: [] },
       });
 
       expect(snapshot).toEqual({
@@ -49,7 +33,8 @@ describe('bufferFeature', () => {
 
       const snapshot = bufferFeature.getSnapshot({
         target: video,
-        initialState: bufferFeature.initialState,
+        get: () => ({ buffered: [], seekable: [] }),
+        initialState: { buffered: [], seekable: [] },
       });
 
       expect(snapshot.buffered).toEqual([
@@ -68,7 +53,12 @@ describe('bufferFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      bufferFeature.subscribe({ target: video, update, signal: controller.signal });
+      bufferFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: () => ({ buffered: [], seekable: [] }),
+      });
       video.dispatchEvent(new Event('progress'));
 
       expect(update).toHaveBeenCalled();
@@ -82,7 +72,12 @@ describe('bufferFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      bufferFeature.subscribe({ target: video, update, signal: controller.signal });
+      bufferFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: () => ({ buffered: [], seekable: [] }),
+      });
       video.dispatchEvent(new Event('emptied'));
 
       expect(update).toHaveBeenCalled();
diff --git a/packages/core/src/dom/store/features/tests/playback.test.ts b/packages/core/src/dom/store/features/tests/playback.test.ts
index 998175bf..d8c1350f 100644
--- a/packages/core/src/dom/store/features/tests/playback.test.ts
+++ b/packages/core/src/dom/store/features/tests/playback.test.ts
@@ -1,42 +1,21 @@
+import { createStore } from '@videojs/store';
+import { noop } from '@videojs/utils/function';
 import { describe, expect, it, vi } from 'vitest';
 
+import type { PlaybackState } from '../playback';
 import { playbackFeature } from '../playback';
 
+const mockState = () =>
+  ({
+    paused: true,
+    ended: false,
+    started: false,
+    waiting: false,
+    play: noop,
+    pause: noop,
+  }) as unknown as PlaybackState;
+
 describe('playbackFeature', () => {
-  describe('feature structure', () => {
-    it('has unique id symbol', () => {
-      expect(playbackFeature.id).toBeTypeOf('symbol');
-    });
-
-    it('has correct initial state', () => {
-      expect(playbackFeature.initialState).toEqual({
-        paused: true,
-        ended: false,
-        started: false,
-        waiting: false,
-      });
-    });
-
-    it('has all request handlers', () => {
-      expect(playbackFeature.request.play).toBeDefined();
-      expect(playbackFeature.request.pause).toBeDefined();
-    });
-
-    it('request handlers have correct structure', () => {
-      expect(playbackFeature.request.play).toMatchObject({
-        key: 'play',
-        guard: [],
-        handler: expect.any(Function),
-      });
-
-      expect(playbackFeature.request.pause).toMatchObject({
-        key: 'pause',
-        guard: [],
-        handler: expect.any(Function),
-      });
-    });
-  });
-
   describe('getSnapshot', () => {
     it('captures current playback state from video element', () => {
       const video = createMockVideo({
@@ -48,7 +27,8 @@ describe('playbackFeature', () => {
 
       const snapshot = playbackFeature.getSnapshot({
         target: video,
-        initialState: playbackFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot).toEqual({
@@ -67,7 +47,8 @@ describe('playbackFeature', () => {
 
       const snapshot = playbackFeature.getSnapshot({
         target: video,
-        initialState: playbackFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot.waiting).toBe(true);
@@ -81,7 +62,8 @@ describe('playbackFeature', () => {
 
       const snapshot = playbackFeature.getSnapshot({
         target: video,
-        initialState: playbackFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot.started).toBe(true);
@@ -95,7 +77,8 @@ describe('playbackFeature', () => {
 
       const snapshot = playbackFeature.getSnapshot({
         target: video,
-        initialState: playbackFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot.started).toBe(true);
@@ -108,7 +91,12 @@ describe('playbackFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      playbackFeature.subscribe({ target: video, update, signal: controller.signal });
+      playbackFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('play'));
 
       expect(update).toHaveBeenCalled();
@@ -119,7 +107,12 @@ describe('playbackFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      playbackFeature.subscribe({ target: video, update, signal: controller.signal });
+      playbackFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('pause'));
 
       expect(update).toHaveBeenCalled();
@@ -130,7 +123,12 @@ describe('playbackFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      playbackFeature.subscribe({ target: video, update, signal: controller.signal });
+      playbackFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('ended'));
 
       expect(update).toHaveBeenCalled();
@@ -141,7 +139,12 @@ describe('playbackFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      playbackFeature.subscribe({ target: video, update, signal: controller.signal });
+      playbackFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       controller.abort();
       video.dispatchEvent(new Event('play'));
 
@@ -149,35 +152,29 @@ describe('playbackFeature', () => {
     });
   });
 
-  describe('request handlers', () => {
-    describe('play', () => {
-      it('calls play on target', async () => {
-        const video = createMockVideo({});
-        video.play = vi.fn().mockResolvedValue(undefined);
+  describe('actions', () => {
+    it('play() calls play on target', async () => {
+      const video = createMockVideo({});
+      video.play = vi.fn().mockResolvedValue(undefined);
 
-        await playbackFeature.request.play.handler(undefined, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+      const store = createStore({ features: [playbackFeature] });
+      store.attach(video);
 
-        expect(video.play).toHaveBeenCalled();
-      });
+      await store.play();
+
+      expect(video.play).toHaveBeenCalled();
     });
 
-    describe('pause', () => {
-      it('calls pause on target', () => {
-        const video = createMockVideo({});
-        video.pause = vi.fn();
+    it('pause() calls pause on target', () => {
+      const video = createMockVideo({});
+      video.pause = vi.fn();
 
-        playbackFeature.request.pause.handler(undefined, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+      const store = createStore({ features: [playbackFeature] });
+      store.attach(video);
 
-        expect(video.pause).toHaveBeenCalled();
-      });
+      store.pause();
+
+      expect(video.pause).toHaveBeenCalled();
     });
   });
 });
diff --git a/packages/core/src/dom/store/features/tests/source.test.ts b/packages/core/src/dom/store/features/tests/source.test.ts
index d3ec7b7e..60c2f2e1 100644
--- a/packages/core/src/dom/store/features/tests/source.test.ts
+++ b/packages/core/src/dom/store/features/tests/source.test.ts
@@ -1,30 +1,18 @@
+import { createStore } from '@videojs/store';
+import { noop } from '@videojs/utils/function';
 import { describe, expect, it, vi } from 'vitest';
 
+import type { SourceState } from '../source';
 import { sourceFeature } from '../source';
 
+const mockState = () =>
+  ({
+    source: null,
+    canPlay: false,
+    loadSource: noop,
+  }) as unknown as SourceState;
+
 describe('sourceFeature', () => {
-  describe('feature structure', () => {
-    it('has unique id symbol', () => {
-      expect(sourceFeature.id).toBeTypeOf('symbol');
-    });
-
-    it('has correct initial state', () => {
-      expect(sourceFeature.initialState).toEqual({
-        source: null,
-        canPlay: false,
-      });
-    });
-
-    it('has changeSource request handler', () => {
-      expect(sourceFeature.request.changeSource).toBeDefined();
-      expect(sourceFeature.request.changeSource).toMatchObject({
-        key: 'changeSource',
-        guard: [],
-        handler: expect.any(Function),
-      });
-    });
-  });
-
   describe('getSnapshot', () => {
     it('captures source state from video element', () => {
       const video = createMockVideo({
@@ -35,7 +23,8 @@ describe('sourceFeature', () => {
 
       const snapshot = sourceFeature.getSnapshot({
         target: video,
-        initialState: sourceFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot).toEqual({
@@ -52,7 +41,8 @@ describe('sourceFeature', () => {
 
       const snapshot = sourceFeature.getSnapshot({
         target: video,
-        initialState: sourceFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot.source).toBe(null);
@@ -66,7 +56,12 @@ describe('sourceFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      sourceFeature.subscribe({ target: video, update, signal: controller.signal });
+      sourceFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('canplay'));
 
       expect(update).toHaveBeenCalled();
@@ -80,7 +75,12 @@ describe('sourceFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      sourceFeature.subscribe({ target: video, update, signal: controller.signal });
+      sourceFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('loadstart'));
 
       expect(update).toHaveBeenCalled();
@@ -91,24 +91,28 @@ describe('sourceFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      sourceFeature.subscribe({ target: video, update, signal: controller.signal });
+      sourceFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('emptied'));
 
       expect(update).toHaveBeenCalled();
     });
   });
 
-  describe('request handlers', () => {
-    describe('changeSource', () => {
-      it('sets src on target and calls load', () => {
+  describe('actions', () => {
+    describe('loadSource', () => {
+      it('sets src on target and calls load', async () => {
         const video = createMockVideo({});
         video.load = vi.fn();
 
-        const result = sourceFeature.request.changeSource.handler('https://example.com/new.mp4', {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+        const store = createStore({ features: [sourceFeature] });
+        store.attach(video);
+
+        const result = await store.loadSource('https://example.com/new.mp4');
 
         expect(video.src).toBe('https://example.com/new.mp4');
         expect(video.load).toHaveBeenCalled();
diff --git a/packages/core/src/dom/store/features/tests/time.test.ts b/packages/core/src/dom/store/features/tests/time.test.ts
index 95f28baa..2585eee8 100644
--- a/packages/core/src/dom/store/features/tests/time.test.ts
+++ b/packages/core/src/dom/store/features/tests/time.test.ts
@@ -1,30 +1,18 @@
+import { createStore } from '@videojs/store';
+import { noop } from '@videojs/utils/function';
 import { describe, expect, it, vi } from 'vitest';
 
+import type { TimeState } from '../time';
 import { timeFeature } from '../time';
 
+const mockState = () =>
+  ({
+    currentTime: 0,
+    duration: 0,
+    seek: noop,
+  }) as unknown as TimeState;
+
 describe('timeFeature', () => {
-  describe('feature structure', () => {
-    it('has unique id symbol', () => {
-      expect(timeFeature.id).toBeTypeOf('symbol');
-    });
-
-    it('has correct initial state', () => {
-      expect(timeFeature.initialState).toEqual({
-        currentTime: 0,
-        duration: 0,
-      });
-    });
-
-    it('has seek request handler', () => {
-      expect(timeFeature.request.seek).toBeDefined();
-      expect(timeFeature.request.seek).toMatchObject({
-        key: 'seek',
-        guard: [],
-        handler: expect.any(Function),
-      });
-    });
-  });
-
   describe('getSnapshot', () => {
     it('captures current time state from video element', () => {
       const video = createMockVideo({
@@ -34,7 +22,8 @@ describe('timeFeature', () => {
 
       const snapshot = timeFeature.getSnapshot({
         target: video,
-        initialState: timeFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot).toEqual({
@@ -51,7 +40,8 @@ describe('timeFeature', () => {
 
       const snapshot = timeFeature.getSnapshot({
         target: video,
-        initialState: timeFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot.duration).toBe(0);
@@ -64,7 +54,12 @@ describe('timeFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      timeFeature.subscribe({ target: video, update, signal: controller.signal });
+      timeFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('timeupdate'));
 
       expect(update).toHaveBeenCalled();
@@ -75,7 +70,12 @@ describe('timeFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      timeFeature.subscribe({ target: video, update, signal: controller.signal });
+      timeFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('durationchange'));
 
       expect(update).toHaveBeenCalled();
@@ -86,7 +86,12 @@ describe('timeFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      timeFeature.subscribe({ target: video, update, signal: controller.signal });
+      timeFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('seeked'));
 
       expect(update).toHaveBeenCalled();
@@ -97,23 +102,26 @@ describe('timeFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      timeFeature.subscribe({ target: video, update, signal: controller.signal });
+      timeFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('emptied'));
 
       expect(update).toHaveBeenCalled();
     });
   });
 
-  describe('request handlers', () => {
+  describe('actions', () => {
     describe('seek', () => {
       it('sets currentTime on target and waits for seeked event', async () => {
         const video = createMockVideo({});
+        const store = createStore({ features: [timeFeature] });
+        store.attach(video);
 
-        const resultPromise = timeFeature.request.seek.handler(45, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+        const resultPromise = store.seek(45);
 
         expect(video.currentTime).toBe(45);
 
@@ -123,21 +131,6 @@ describe('timeFeature', () => {
         const result = await resultPromise;
         expect(result).toBe(45);
       });
-
-      it('rejects if signal is aborted before seeked', async () => {
-        const video = createMockVideo({});
-        const controller = new AbortController();
-
-        const resultPromise = timeFeature.request.seek.handler(30, {
-          target: video,
-          signal: controller.signal,
-          meta: null,
-        });
-
-        controller.abort();
-
-        await expect(resultPromise).rejects.toThrow();
-      });
     });
   });
 });
diff --git a/packages/core/src/dom/store/features/tests/volume.test.ts b/packages/core/src/dom/store/features/tests/volume.test.ts
index 79a1ebaf..512cdf9c 100644
--- a/packages/core/src/dom/store/features/tests/volume.test.ts
+++ b/packages/core/src/dom/store/features/tests/volume.test.ts
@@ -1,26 +1,19 @@
+import { createStore } from '@videojs/store';
+import { noop } from '@videojs/utils/function';
 import { describe, expect, it, vi } from 'vitest';
 
+import type { VolumeState } from '../volume';
 import { volumeFeature } from '../volume';
 
+const mockState = () =>
+  ({
+    volume: 1,
+    muted: false,
+    changeVolume: noop,
+    toggleMute: noop,
+  }) as unknown as VolumeState;
+
 describe('volumeFeature', () => {
-  describe('feature structure', () => {
-    it('has unique id symbol', () => {
-      expect(volumeFeature.id).toBeTypeOf('symbol');
-    });
-
-    it('has correct initial state', () => {
-      expect(volumeFeature.initialState).toEqual({
-        volume: 1,
-        muted: false,
-      });
-    });
-
-    it('has all request handlers', () => {
-      expect(volumeFeature.request.changeVolume).toBeDefined();
-      expect(volumeFeature.request.toggleMute).toBeDefined();
-    });
-  });
-
   describe('getSnapshot', () => {
     it('captures volume state from video element', () => {
       const video = createMockVideo({
@@ -30,7 +23,8 @@ describe('volumeFeature', () => {
 
       const snapshot = volumeFeature.getSnapshot({
         target: video,
-        initialState: volumeFeature.initialState,
+        get: mockState,
+        initialState: mockState(),
       });
 
       expect(snapshot).toEqual({
@@ -46,75 +40,70 @@ describe('volumeFeature', () => {
       const update = vi.fn();
       const controller = new AbortController();
 
-      volumeFeature.subscribe({ target: video, update, signal: controller.signal });
+      volumeFeature.subscribe({
+        target: video,
+        update,
+        signal: controller.signal,
+        get: mockState,
+      });
       video.dispatchEvent(new Event('volumechange'));
 
       expect(update).toHaveBeenCalled();
     });
   });
 
-  describe('request handlers', () => {
+  describe('actions', () => {
     describe('changeVolume', () => {
-      it('sets volume on target', () => {
+      it('sets volume on target', async () => {
         const video = createMockVideo({});
+        const store = createStore({ features: [volumeFeature] });
+        store.attach(video);
 
-        const result = volumeFeature.request.changeVolume.handler(0.7, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+        const result = await store.changeVolume(0.7);
 
         expect(video.volume).toBe(0.7);
         expect(result).toBe(0.7);
       });
 
-      it('clamps volume to min 0', () => {
+      it('clamps volume to min 0', async () => {
         const video = createMockVideo({});
+        const store = createStore({ features: [volumeFeature] });
+        store.attach(video);
 
-        volumeFeature.request.changeVolume.handler(-0.5, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+        await store.changeVolume(-0.5);
 
         expect(video.volume).toBe(0);
       });
 
-      it('clamps volume to max 1', () => {
+      it('clamps volume to max 1', async () => {
         const video = createMockVideo({});
+        const store = createStore({ features: [volumeFeature] });
+        store.attach(video);
 
-        volumeFeature.request.changeVolume.handler(1.5, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+        await store.changeVolume(1.5);
 
         expect(video.volume).toBe(1);
       });
     });
 
     describe('toggleMute', () => {
-      it('toggles mute from false to true', () => {
+      it('toggles mute from false to true', async () => {
         const video = createMockVideo({ muted: false });
+        const store = createStore({ features: [volumeFeature] });
+        store.attach(video);
 
-        const result = volumeFeature.request.toggleMute.handler(undefined, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+        const result = await store.toggleMute();
 
         expect(video.muted).toBe(true);
         expect(result).toBe(true);
       });
 
-      it('toggles mute from true to false', () => {
+      it('toggles mute from true to false', async () => {
         const video = createMockVideo({ muted: true });
+        const store = createStore({ features: [volumeFeature] });
+        store.attach(video);
 
-        const result = volumeFeature.request.toggleMute.handler(undefined, {
-          target: video,
-          signal: new AbortController().signal,
-          meta: null,
-        });
+        const result = await store.toggleMute();
 
         expect(video.muted).toBe(false);
         expect(result).toBe(false);
diff --git a/packages/core/src/dom/store/features/time.ts b/packages/core/src/dom/store/features/time.ts
index 904c08c9..dfa449fa 100644
--- a/packages/core/src/dom/store/features/time.ts
+++ b/packages/core/src/dom/store/features/time.ts
@@ -1,20 +1,27 @@
-import type { InferFeatureRequests, InferFeatureState } from '@videojs/store';
+import type { InferFeatureState } from '@videojs/store';
 
-import { createFeature } from '@videojs/store';
+import { defineFeature } from '@videojs/store';
 import { listen, onEvent } from '@videojs/utils/dom';
 
-/**
- * Time feature for HTMLMediaElement.
- *
- * Tracks current time and duration, provides seek control.
- */
-export const timeFeature = createFeature<HTMLMediaElement>()({
-  initialState: {
+export const timeFeature = defineFeature<HTMLMediaElement>()({
+  state: ({ task }) => ({
     /** Current playback position in seconds. */
     currentTime: 0,
     /** Total duration in seconds (0 if unknown). */
     duration: 0,
-  },
+
+    /** Seek to a time in seconds. Returns the requested time. */
+    seek(time: number) {
+      return task({
+        key: 'seek',
+        async handler({ target, signal }) {
+          target.currentTime = time;
+          await onEvent(target, 'seeked', { signal });
+          return target.currentTime; // actual position after seek
+        },
+      });
+    },
+  }),
 
   getSnapshot: ({ target }) => ({
     currentTime: target.currentTime,
@@ -28,17 +35,6 @@ export const timeFeature = createFeature<HTMLMediaElement>()({
     listen(target, 'loadedmetadata', update, { signal });
     listen(target, 'emptied', update, { signal });
   },
-
-  request: {
-    /** Seek to a time in seconds. Returns the requested time. */
-    seek: async (time: number, { target, signal }) => {
-      target.currentTime = time;
-      await onEvent(target, 'seeked', { signal });
-      return target.currentTime; // actual position after seek
-    },
-  },
 });
 
 export type TimeState = InferFeatureState<typeof timeFeature>;
-
-export type TimeRequests = InferFeatureRequests<typeof timeFeature>;
diff --git a/packages/core/src/dom/store/features/volume.ts b/packages/core/src/dom/store/features/volume.ts
index 3b050d62..deda7bf7 100644
--- a/packages/core/src/dom/store/features/volume.ts
+++ b/packages/core/src/dom/store/features/volume.ts
@@ -1,20 +1,37 @@
-import type { InferFeatureRequests, InferFeatureState } from '@videojs/store';
+import type { InferFeatureState } from '@videojs/store';
 
-import { createFeature } from '@videojs/store';
+import { defineFeature } from '@videojs/store';
 import { listen } from '@videojs/utils/dom';
 
-/**
- * Volume feature for HTMLMediaElement.
- *
- * Tracks volume and mute state, provides volume control.
- */
-export const volumeFeature = createFeature<HTMLMediaElement>()({
-  initialState: {
+export const volumeFeature = defineFeature<HTMLMediaElement>()({
+  state: ({ task }) => ({
     /** Volume level from 0 (silent) to 1 (max). */
     volume: 1,
     /** Whether audio is muted. */
     muted: false,
-  },
+
+    /** Set volume (clamped 0-1). Returns the clamped value. */
+    changeVolume(volume: number) {
+      return task({
+        key: 'volume',
+        handler({ target }) {
+          target.volume = Math.max(0, Math.min(1, volume));
+          return target.volume;
+        },
+      });
+    },
+
+    /** Toggle mute state. Returns new muted value. */
+    toggleMute() {
+      return task({
+        key: 'mute',
+        handler({ target }) {
+          target.muted = !target.muted;
+          return target.muted;
+        },
+      });
+    },
+  }),
 
   getSnapshot: ({ target }) => ({
     volume: target.volume,
@@ -24,22 +41,6 @@ export const volumeFeature = createFeature<HTMLMediaElement>()({
   subscribe: ({ target, update, signal }) => {
     listen(target, 'volumechange', update, { signal });
   },
-
-  request: {
-    /** Set volume (clamped 0-1). Returns the clamped value. */
-    changeVolume: (volume: number, { target }) => {
-      target.volume = Math.max(0, Math.min(1, volume));
-      return target.volume;
-    },
-
-    /** Toggle mute state. Returns new muted value. */
-    toggleMute: (_, { target }) => {
-      target.muted = !target.muted;
-      return target.muted;
-    },
-  },
 });
 
 export type VolumeState = InferFeatureState<typeof volumeFeature>;
-
-export type VolumeRequests = InferFeatureRequests<typeof volumeFeature>;
diff --git a/packages/react/src/media/tests/video.test.tsx b/packages/react/src/media/tests/video.test.tsx
index 1244dc82..1285bbc7 100644
--- a/packages/react/src/media/tests/video.test.tsx
+++ b/packages/react/src/media/tests/video.test.tsx
@@ -1,6 +1,6 @@
 import { render } from '@testing-library/react';
 
-import { createFeature } from '@videojs/store';
+import { defineFeature } from '@videojs/store';
 import { createStore, useStoreContext } from '@videojs/store/react';
 import { describe, expect, it, vi } from 'vitest';
 
@@ -12,14 +12,16 @@ describe('video', () => {
     muted = false;
   }
 
-  const mockFeature = createFeature<MockMedia>()({
-    initialState: { volume: 1, muted: false },
+  const mockFeature = defineFeature<MockMedia>()({
+    state: () => ({
+      volume: 1,
+      muted: false,
+    }),
     getSnapshot: ({ target }) => ({
       volume: target.volume,
       muted: target.muted,
     }),
     subscribe: () => {},
-    request: {},
   });
 
   function createTestStore() {
diff --git a/packages/store/README.md b/packages/store/README.md
index 4e442634..727aba8a 100644
--- a/packages/store/README.md
+++ b/packages/store/README.md
@@ -20,27 +20,27 @@ npm install @videojs/store
 - **Write Path**: Send requests, coordinate execution, handle failures
 
 ```ts
-import { createFeature, createStore } from '@videojs/store';
+import { createStore } from '@videojs/store';
 
 const store = createStore({
-  features: [playbackFeature, audioFeature],
+  features: [playbackFeature, volumeFeature],
 });
 
-store.attach(videoElement); // <video>
+store.attach(videoElement);
 
-// State is synced from target
-const { paused, volume } = store.state;
+// State is flat on the store
+const { paused, volume } = store;
 
-// Requests are coordinated async operations
-await store.request.play();
-await store.request.setVolume(0.5);
+// Actions are flat on the store
+await store.play();
+store.setVolume(0.5);
 ```
 
 ## Core Concepts
 
 ### Target
 
-The target contains a reference to an external systems. Features read from and write to it.
+The target is a reference to the external system. Features read from and write to it.
 
 ```ts
 const videoElement = document.querySelector('video');
@@ -49,149 +49,161 @@ store.attach(videoElement);
 
 ### Features
 
-A feature defines state, how to sync it from the target, and requests to modify the target.
+A feature defines state, how to sync it from the target, and actions to modify the target.
 
 ```ts
-// createFeature<Target>()() - curried form enables full type inference
-const audioFeature = createFeature<HTMLMediaElement>()({
-  initialState: { volume: 1, muted: false },
+import { defineFeature } from '@videojs/store';
+import { listen } from '@videojs/utils/dom';
 
+const volumeFeature = defineFeature<HTMLMediaElement>()({
+  // State factory - returns initial state and actions
+  state: ({ task }) => ({
+    // State (plain values)
+    volume: 1,
+    muted: false,
+
+    // Action - async, tracked
+    changeVolume(volume: number) {
+      return task({
+        key: 'volume',
+        handler({ target }) {
+          target.volume = Math.max(0, Math.min(1, volume));
+          return target.volume;
+        },
+      });
+    },
+
+    // Action - async, tracked
+    toggleMute() {
+      return task({
+        key: 'mute',
+        handler({ target }) {
+          target.muted = !target.muted;
+          return target.muted;
+        },
+      });
+    },
+  }),
+
+  // Sync state from target
   getSnapshot: ({ target }) => ({
     volume: target.volume,
     muted: target.muted,
   }),
 
+  // Subscribe to target events
   subscribe: ({ target, update, signal }) => {
-    target.addEventListener('volumechange', update, { signal });
-  },
-
-  request: {
-    setVolume(volume: number, { target, meta, signal }) {
-      target.volume = volume;
-    },
-
-    setMuted(muted: boolean, { target, meta, signal }) {
-      target.muted = muted;
-    },
+    listen(target, 'volumechange', update, { signal });
   },
 });
 ```
 
 ### Feature Type Inference
 
-State and request types are fully inferred from the feature config:
+State types are fully inferred from the feature config:
 
 ```ts
-import type { InferFeatureRequests, InferFeatureState } from '@videojs/store';
+import type { InferFeatureState } from '@videojs/store';
 
-const audioFeature = createFeature<HTMLMediaElement>()({
-  initialState: { volume: 1, muted: false },
+const volumeFeature = defineFeature<HTMLMediaElement>()({
+  state: () => ({ volume: 1, muted: false, /* actions */ }),
   // ...
 });
 
 // Infer types from the feature
-type AudioState = InferFeatureState<typeof audioFeature>;
-type AudioRequests = InferFeatureRequests<typeof audioFeature>;
+type VolumeState = InferFeatureState<typeof volumeFeature>;
+// { volume: number; muted: boolean; changeVolume: ...; toggleMute: ... }
 ```
 
 For stores with multiple features:
 
 ```ts
-import type { UnionFeatureRequests, UnionFeatureState } from '@videojs/store';
+import type { UnionFeatureState } from '@videojs/store';
 
-const features = [audioFeature, playbackFeature] as const;
+const features = [volumeFeature, playbackFeature] as const;
 
 type MediaState = UnionFeatureState<typeof features>;
-type MediaRequests = UnionFeatureRequests<typeof features>;
 ```
 
-### Explicit Feature Types
+### Actions
 
-For upfront type definitions, use `Request<Input, Output>`:
+Actions modify the target. Use `task()` for async operations with tracking, or access the target directly for simple sync mutations.
 
 ```ts
-import type { Request } from '@videojs/store';
+state: ({ task, target }) => ({
+  volume: 1,
 
-import { createFeature } from '@videojs/store';
+  // Async action with tracking
+  changeVolume(volume: number) {
+    return task({
+      key: 'volume',
+      handler({ target }) {
+        target.volume = volume;
+        return target.volume;
+      },
+    });
+  },
 
-interface AudioState {
-  volume: number;
-  muted: boolean;
-}
+  // Sync action - direct target access
+  setVolumeDirect(volume: number) {
+    target().volume = volume;
+  },
 
-interface AudioRequests {
-  setVolume: Request<number>; // (volume: number) => Promise<void>
-  setMuted: Request<boolean>; // (muted: boolean) => Promise<void>
-  play: Request; // () => Promise<void>
-  getDuration: Request<void, number>; // () => Promise<number>
-}
-
-const audioFeature = createFeature<HTMLMediaElement, AudioState, AudioRequests>({
-  // Types enforced from interfaces
-});
+  // Async action - fire-and-forget (no tracking)
+  logVolume() {
+    return task(({ target }) => {
+      console.log('Current volume:', target.volume);
+    });
+  },
+}),
 ```
 
-### Requests
+The `task()` helper provides:
 
-Requests are operations against the target. Use function shorthand for simple cases, or full config for guards and scheduling.
+- **Tracked execution** — Tasks with a `key` appear in `store.pending`
+- **Cancellation** — Handlers receive `signal: AbortSignal`
+- **Coordination** — Tasks with the same key supersede each other
+- **State access** — Handlers can read current state via `get()`
 
 ```ts
-import { onEvent } from '@videojs/utils/events';
+handler({ target, signal, get, meta }) {
+  // target - the attached target
+  // signal - AbortSignal for cancellation
+  // get() - current state snapshot
+  // meta - request metadata (from store.meta())
+}
+```
 
-request: {
-  // Shorthand - just the handler
-  setVolume(volume, { target }) {
-    target.volume = volume;
-  },
+### Action Metadata
 
-  // Async shorthand
-  async seek(time, { target, signal }) {
-    target.currentTime = time;
-    await onEvent(target, 'seeked', { signal });
-  },
+Pass metadata to actions for observability and debugging:
 
-  // Full config when needed
-  play: {
-    key: 'playback',
-    mode: 'shared',
-    guard: [],
-    cancel: [],
-    async handler(_, { target, signal }) {
-      target.play();
-      await onEvent(target, 'play', { signal });
+```ts
+// From DOM event
+store.meta(clickEvent).play();
+store.meta(keyEvent).seek(10);
+
+// Explicit metadata
+store.meta({ source: 'keyboard', reason: 'shortcut' }).play();
+
+// Chain multiple actions with same context
+const m = store.meta(event);
+m.play();
+m.seek(30);
+```
+
+Handlers receive metadata via the context:
+
+```ts
+changeVolume(volume: number) {
+  return task({
+    key: 'volume',
+    handler({ target, meta }) {
+      console.log(`Volume change from: ${meta?.source}`);
+      target.volume = volume;
     },
-  },
-}
-```
-
-Consumer API is consistent, all requests return a Promise:
-
-```ts
-await store.request.setVolume(0.5);
-await store.request.play();
-await store.request.seek(30);
-```
-
-### Request Metadata
-
-Every request accepts optional metadata as the last argument.
-
-```ts
-store.request.play(undefined, { source: 'user', reason: 'play-button' });
-store.request.seek(30, { source: 'user', reason: 'slider-scrub' });
-store.request.pause(undefined, { source: 'system', reason: 'ad-start' });
-
-// Infer metadata from DOM event
-store.request.play(undefined, createRequestMetaFromEvent(clickEvent)); // MouseEvent
-```
-
-Handlers receive metadata:
-
-```ts
-async handler(_, { target, signal, meta }) {
-  console.log(`[${meta.source}] play: ${meta.reason}`);
-  // ...
-}
+  });
+},
 ```
 
 ## Store
@@ -200,7 +212,7 @@ The store composes features and manages the target connection.
 
 ```ts
 const store = createStore({
-  features: [playbackFeature, audioFeature],
+  features: [playbackFeature, volumeFeature],
 
   onSetup: ({ store, signal }) => {
     // Called when store is created
@@ -213,18 +225,26 @@ const store = createStore({
   onError: ({ error, store }) => {
     // Global error handler
   },
+
+  onTaskStart: ({ key, meta }) => {
+    // Called when a tracked task starts
+  },
+
+  onTaskEnd: ({ key, meta, error }) => {
+    // Called when a tracked task completes
+  },
 });
 ```
 
 ### Type Inference
 
 ```ts
-import type { InferStoreRequests, InferStoreState } from '@videojs/store';
+import type { InferStoreState, InferStoreTarget } from '@videojs/store';
 
-const store = createStore({ features: [audioFeature, playbackFeature] });
+const store = createStore({ features: [volumeFeature, playbackFeature] });
 
 type State = InferStoreState<typeof store>;
-type Requests = InferStoreRequests<typeof store>;
+type Target = InferStoreTarget<typeof store>;
 ```
 
 ### Attaching a Target
@@ -232,11 +252,12 @@ type Requests = InferStoreRequests<typeof store>;
 ```ts
 const detach = store.attach(videoElement);
 
-// State syncs from target
-const { paused, volume } = store.state;
+// State syncs from target (flat access)
+const { paused, volume } = store;
 
-// Requests go to target
-store.request.play();
+// Actions go to target (flat access)
+store.play();
+store.setVolume(0.5);
 
 // Detach when done
 detach();
@@ -247,7 +268,7 @@ detach();
 Clean up when the store is no longer needed:
 
 ```ts
-// Detaches target, aborts pending requests, clears queue
+// Detaches target, aborts pending tasks, cleans up
 store.destroy();
 ```
 
@@ -256,196 +277,143 @@ store.destroy();
 State is reactive—subscribe to be notified when any property changes:
 
 ```ts
-// Subscribe to all state changes
 const unsubscribe = store.subscribe(() => {
-  const { volume } = store.state;
+  const { volume } = store;
   console.log('State changed:', volume);
 });
-
-// Subscribe to specific keys only
-store.subscribe(['volume', 'muted'], () => {
-  const { volume, muted } = store.state;
-  console.log('Audio changed:', volume, muted);
-});
 ```
 
 Mutations are auto-batched—multiple changes in the same tick trigger only one notification.
 
-Features sync state from the target via `getSnapshot`. The `update` callback triggers a sync, and the store only notifies subscribers for keys that actually changed:
+### Pending Tasks
+
+Track in-flight async operations:
 
 ```ts
-subscribe: ({ target, update, signal }) => {
-  // Each event triggers a full sync via getSnapshot
-  // Only changed keys notify their subscribers
-  target.addEventListener('timeupdate', update, { signal });
-  target.addEventListener('durationchange', update, { signal });
-};
-```
+// Check if a task is running
+if (store.pending.playback) {
+  console.log('Playback task in progress...');
+}
 
-## Request Configuration
-
-### Keys
-
-Requests with the same key coordinate together. Default key is the request name.
-
-```ts
-request: {
-  play: {
-    key: 'playback',
-    handler: async (_, { target }) => { ... },
-  },
-  pause: {
-    key: 'playback',  // same key - coordinates with play
-    handler: async (_, { target }) => { ... },
-  },
+// Pending task info
+const task = store.pending.volume;
+if (task) {
+  console.log(task.key);       // 'volume'
+  console.log(task.startedAt); // timestamp
+  console.log(task.meta);      // RequestMeta | null
 }
 ```
 
-When a new request arrives with the same key:
+## Task Configuration
 
-- Pending request with that key is aborted
-- New request takes over
+### Keys
+
+Tasks with the same key coordinate together. When a new task arrives with the same key, the pending task is aborted and the new one takes over.
 
 ```ts
-store.request.play(); // starts immediately
-store.request.pause(); // aborts play, starts immediately
-// both start, but play is aborted mid-flight
+state: ({ task }) => ({
+  play() {
+    return task({
+      key: 'playback',
+      handler: ({ target }) => target.play(),
+    });
+  },
+
+  pause() {
+    return task({
+      key: 'playback', // same key - coordinates with play
+      handler: ({ target }) => target.pause(),
+    });
+  },
+}),
+```
+
+```ts
+store.play();  // starts immediately
+store.pause(); // aborts play, starts immediately
 ```
 
 Dynamic keys for parallel execution:
 
 ```ts
-request: {
-  // Each call gets unique key - no coordination
-  logEvent: {
-    key: () => Symbol(),
-    handler: (data) => analytics.log(data),
-  },
+// Each call gets unique key - no coordination
+logEvent(data: unknown) {
+  return task({
+    key: Symbol(),
+    handler: () => analytics.log(data),
+  });
+},
 
-  // Key based on input
-  loadTrack: {
-    key: (trackId) => `track-${trackId}`,
-    handler: (trackId, { target }) => target.loadTrack(trackId),
-  },
-}
+// Key based on input
+loadTrack(trackId: string) {
+  return task({
+    key: `track-${trackId}`,
+    handler: ({ target }) => target.loadTrack(trackId),
+  });
+},
 ```
 
 ### Mode
 
-The `mode` option controls how requests with the same key interact:
+The `mode` option controls how tasks with the same key interact:
 
-| Mode                    | Behavior                         | Use case            |
-| ----------------------- | -------------------------------- | ------------------- |
-| `'exclusive'` (default) | Supersede pending request        | seek, pause, volume |
-| `'shared'`              | Join pending request, share fate | play                |
+| Mode                    | Behavior                  | Use case            |
+| ----------------------- | ------------------------- | ------------------- |
+| `'exclusive'` (default) | Supersede pending task    | seek, pause, volume |
+| `'shared'`              | Join pending task         | play                |
 
 ```ts
-request: {
-  play: {
+play() {
+  return task({
     key: 'playback',
-    mode: 'shared',  // Multiple play() calls share the same outcome
-    async handler(_, { target }) {
+    mode: 'shared', // Multiple play() calls share the same outcome
+    async handler({ target }) {
       await target.play();
     },
-  },
-  pause: {
+  });
+},
+
+pause() {
+  return task({
     key: 'playback',
-    mode: 'exclusive',  // default - supersedes play
-    handler: (_, { target }) => target.pause(),
-  },
-}
+    mode: 'exclusive', // default - supersedes play
+    handler: ({ target }) => target.pause(),
+  });
+},
 ```
 
-With `mode: 'shared'`, multiple calls while a request is pending all resolve/reject together:
+With `mode: 'shared'`, multiple calls while a task is pending all resolve/reject together:
 
 ```ts
-const p1 = store.request.play(); // starts
-const p2 = store.request.play(); // joins p1
-const p3 = store.request.play(); // joins p1
-// All three resolve/reject together when playback starts or fails
+const p1 = store.play(); // starts
+const p2 = store.play(); // joins p1
+const p3 = store.play(); // joins p1
+// All three resolve/reject together
 ```
 
 ### Cancels
 
-Requests can cancel other in-flight requests by name. Cancellation happens immediately when the
-request is enqueued, before guards.
+Tasks can cancel other in-flight tasks by key:
 
 ```ts
 import { CANCEL_ALL } from '@videojs/store';
 
-request: {
-  stop: {
-    cancel: ['seek', 'preload'],  // Request names to cancel
-    handler: (_, { target }) => target.pause(),
-  },
+stop() {
+  return task({
+    cancels: ['seek', 'preload'], // Keys to cancel
+    handler: ({ target }) => target.pause(),
+  });
+},
 
-  load: {
-    cancel: CANCEL_ALL,  // Nuclear reset - cancels ALL pending requests
-    handler: (src, { target }) => {
+load(src: string) {
+  return task({
+    cancels: CANCEL_ALL, // Cancel ALL pending tasks
+    handler: ({ target }) => {
       target.src = src;
       target.load();
     },
-  },
-}
-```
-
-### Guards
-
-Guards gate request execution. A guard returns a `GuardResult`:
-
-```ts
-import type { Guard, GuardResult } from '@videojs/store';
-
-// GuardResult = boolean | Promise<unknown>
-// - Truthy → proceed
-// - Falsy → cancel (throws REJECTED)
-// - Promise resolves truthy → proceed
-// - Promise resolves falsy → cancel
-// - Promise rejects → cancel
-```
-
-```ts
-import { timeout } from '@videojs/store';
-
-request: {
-  seek: {
-    guard: [hasMetadata, /* ... */],
-    handler: (time, { target }) => {
-      target.media.currentTime = time;
-    },
-  },
-
-  play: {
-    guard: timeout(isTargetReady, 5000),
-    handler: (_, { target }) => target.media.play(),
-  },
-}
-```
-
-**Custom guard:**
-
-```ts
-import type { Guard } from '@videojs/store';
-
-import { onEvent } from '@videojs/utils/events';
-
-const canMediaPlay: Guard<HTMLMediaElement> = ({ target, signal }) => {
-  if (target.readyState >= HAVE_ENOUGH_DATA) return true;
-  return onEvent(target, 'canplay', { signal }); // wait for canplay
-};
-```
-
-**Combinators:**
-
-```ts
-// All must be truthy
-const canSeek = all(hasMedia, canMediaPlay, notMediaSeeking);
-
-// First truthy wins
-const ready = any(canMediaPlay, canMediaPlayThrough);
-
-// Reject if guard doesn't resolve in time
-const timedPlay = timeout(canMediaPlay, 5000);
+  });
+},
 ```
 
 ## Error Handling
@@ -454,46 +422,36 @@ All store errors include a `code` for programmatic handling:
 
 | Code         | Description                  |
 | ------------ | ---------------------------- |
-| `ABORTED`    | Request aborted via signal   |
-| `CANCELLED`  | Cancelled by another request |
-| `DESTROYED`  | Store or queue destroyed     |
+| `ABORTED`    | Task aborted via signal      |
+| `DESTROYED`  | Store destroyed              |
 | `DETACHED`   | Target detached              |
 | `NO_TARGET`  | No target attached           |
-| `REJECTED`   | Guard returned falsy         |
-| `SUPERSEDED` | Replaced by same-key request |
-| `TIMEOUT`    | Guard timed out              |
+| `SUPERSEDED` | Replaced by same-key task    |
 
-Catch errors locally via the promise, or globally via `onError`:
+Handle errors locally via the promise, or globally via `onError`:
 
 ```ts
 import { isStoreError } from '@videojs/store';
 
-// 1. Global Error Handling
+// Global error handling
 const store = createStore({
   features: [playbackFeature],
-  onError: ({ error, request }) => {
-    if (request) {
-      console.error(`${request.name} failed`);
-    }
-
-    console.error(error);
+  onError: ({ error, store }) => {
+    console.error('Store error:', error);
   },
 });
 
-// 2. Local Error Handling
+// Local error handling
 try {
-  await store.request.play();
+  await store.play();
 } catch (error) {
   if (isStoreError(error)) {
     switch (error.code) {
       case 'SUPERSEDED':
-        // Another play/pause request took over - expected
+        // Another task took over - expected
         break;
-      case 'REJECTED':
-        // Guard failed - blocked
-        break;
-      case 'TIMEOUT':
-        // Guard timed out waiting
+      case 'NO_TARGET':
+        // No media element attached
         break;
       default:
         console.error(`[${error.code}]`, error.message);
@@ -502,115 +460,11 @@ try {
 }
 ```
 
-## Queue
-
-The queue manages request execution with automatic supersession and lifecycle tracking. A default queue is created automatically with the store.
-
-### Queue API
-
-```ts
-const queue = store.queue;
-
-// Task lifecycle map (pending/success/error) keyed by request name
-queue.tasks;
-
-// Abort executing tasks
-queue.abort('play'); // abort specific request
-queue.abort(); // abort all
-
-// Clear settled tasks (success/error results)
-queue.reset('seek'); // clear specific request
-queue.reset(); // clear all settled
-
-// Subscribe to task changes
-queue.subscribe(() => {
-  const { play } = queue.tasks;
-  if (play?.status === 'pending') {
-    console.log('Play in progress...');
-  }
-});
-```
-
-### Task Lifecycle
-
-Each request creates a task that transitions through states:
-
-```ts
-import { isErrorTask, isPendingTask, isSettledTask, isSuccessTask } from '@videojs/store';
-
-const { play: task } = queue.tasks;
-
-// Type guards for status checking
-if (isPendingTask(task)) {
-  console.log('In progress, started at:', task.startedAt);
-}
-
-if (isSettledTask(task)) {
-  console.log('Duration:', task.settledAt - task.startedAt);
-}
-
-if (isSuccessTask(task)) {
-  console.log('Result:', task.output);
-}
-
-if (isErrorTask(task)) {
-  console.log('Failed:', task.error);
-  console.log('Was cancelled:', task.cancelled);
-}
-```
-
-### Direct Queue Usage
-
-You can use the queue directly without a store:
-
-```ts
-import { createQueue } from '@videojs/store';
-
-const queue = createQueue();
-
-await queue.enqueue({
-  name: 'myTask',
-  key: 'task-key',
-  input: { some: 'data' },
-  handler: async ({ input, signal }) => {
-    // do work, check signal.aborted
-    return result;
-  },
-});
-```
-
-### Observing Tasks
-
-Use `subscribe` to react to task changes—useful for loading states and error handling:
-
-```ts
-queue.subscribe(() => {
-  for (const [name, task] of Object.entries(queue.tasks)) {
-    if (task?.status === 'error' && !task.cancelled) {
-      toast.error(`${name} failed: ${task.error}`);
-    }
-  }
-});
-
-// Analytics
-queue.subscribe(() => {
-  for (const task of Object.values(queue.tasks)) {
-    if (task && task.status !== 'pending') {
-      analytics.track('request', {
-        name: task.name,
-        status: task.status,
-        duration: task.settledAt - task.startedAt,
-      });
-    }
-  }
-});
-```
-
 ## Advanced
 
 ### State Primitives
 
-The store uses explicit state containers internally. You can also use these primitives directly:
+The store uses explicit state containers internally. You can use these primitives directly:
 
 ```ts
 import { createState, flush, isState } from '@videojs/store';
@@ -618,7 +472,7 @@ import { createState, flush, isState } from '@videojs/store';
 // Create state container
 const state = createState({ volume: 1, muted: false });
 
-// Read via destructuring from .current
+// Read via .current
 const { volume } = state.current; // 1
 
 // Mutate via set() or patch() - changes are auto-batched
@@ -626,18 +480,12 @@ state.set('volume', 0.5);
 state.patch({ volume: 0.5, muted: true });
 // Only ONE notification fires (after microtask)
 
-// Subscribe to all changes
+// Subscribe to changes
 state.subscribe(() => {
   const { volume } = state.current;
   console.log('Changed:', volume);
 });
 
-// Subscribe to specific keys
-state.subscribe(['volume'], () => {
-  const { volume } = state.current;
-  console.log('Volume:', volume);
-});
-
 // Check if value is state
 isState(state); // true
 
@@ -645,33 +493,24 @@ isState(state); // true
 flush();
 ```
 
-### Computed Values
-
-Derive reactive values from state:
-
-```ts
-import { createComputed } from '@videojs/store';
-
-const effectiveVolume = createComputed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-
-effectiveVolume.current; // derived value
-effectiveVolume.subscribe(() => console.log('changed'));
-effectiveVolume.destroy(); // cleanup when done
-```
-
-Computed values only notify when the derived result actually changes.
-
 ### Capability Checking
 
 Features can expose capability via state. UI components check before rendering.
 
 ```ts
-const qualityFeature = createFeature<Media>({
-  initialState: {
-   supported: false ,
-   levels: [],
-   currentLevel: -1
- },
+const qualityFeature = defineFeature<Media>()({
+  state: ({ task }) => ({
+    supported: false,
+    levels: [] as QualityLevel[],
+    currentLevel: -1,
+
+    setLevel(index: number) {
+      return task({
+        key: 'quality',
+        handler: ({ target }) => target.setQualityLevel(index),
+      });
+    },
+  }),
 
   getSnapshot: ({ target, initialState }) => {
     if (target.canSetVideoQuality) {
@@ -681,19 +520,17 @@ const qualityFeature = createFeature<Media>({
         currentLevel: target.currentLevel,
       };
     }
-
     return initialState; // supported: false
   },
 
-  // ...
+  subscribe: ({ target, update, signal }) => {
+    target.addEventListener('qualitychange', update, { signal });
+  },
 });
 
 // UI checks capability
 function QualityMenu() {
-  const { supported, levels } = useStore(store, (s) => ({
-    supported: s.supported,
-    levels: s.levels
-  }));
+  const { supported, levels } = store;
 
   if (!supported) return null;
 
@@ -701,26 +538,12 @@ function QualityMenu() {
 }
 ```
 
-### Optional Features
-
-Check if a feature exists at runtime:
-
-```tsx
-function QualityMenu() {
-  const quality = useFeature(store, qualityFeature);
-
-  if (!quality) return null;
-
-  return <Menu items={quality.state.levels} />;
-}
-```
-
 ## How It's Different
 
 |                   | Redux/Zustand    | React Query           | @videojs/store             |
 | ----------------- | ---------------- | --------------------- | -------------------------- |
 | **Authority**     | You own state    | Server owns state     | External system owns state |
-| **Mutations**     | Sync reducers    | Async server requests | Async requests to target   |
+| **Mutations**     | Sync reducers    | Async server requests | Async tasks to target      |
 | **State source**  | Internal store   | HTTP cache            | `getSnapshot` from target  |
 | **Subscriptions** | To store changes | To query cache        | To target events           |
 | **Use case**      | App state        | Server data           | Media, WebSocket, hardware |
@@ -734,14 +557,13 @@ function QualityMenu() {
 ```ts
 // Redux approach - fighting the abstraction
 dispatch(play());
-
 // Hope the video actually plays...
 // Manually sync video.paused back to store...
 // Handle race conditions...
 
 // @videojs/store - working with the abstraction
-await store.request.play(); // Resolves when actually playing
-const { paused } = store.state; // Always reflects video.paused
+await store.play();           // Resolves when task completes
+const { paused } = store;     // Always reflects video.paused
 ```
 
 ## Community
diff --git a/packages/store/src/core/computed.ts b/packages/store/src/core/computed.ts
deleted file mode 100644
index 4851dddc..00000000
--- a/packages/store/src/core/computed.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import type { State } from './state';
-
-/**
- * Create a computed value derived from state.
- *
- * @example
- * ```ts
- * const effectiveVolume = createComputed(state, ['volume', 'muted'], ({ volume, muted }) => muted ? 0 : volume);
- * ```
- */
-export function createComputed<T extends object, K extends keyof T, R>(
-  state: State<T>,
-  keys: K[],
-  derive: (snapshot: Pick<T, K>) => R
-): Computed<T, K, R> {
-  return new Computed(state, keys, derive);
-}
-
-/**
- * A computed value derived from state.
- *
- * The derived value is recomputed when any of the specified keys change.
- * Subscribers are notified only when the computed value actually changes.
- *
- * @example
- * ```ts
- * const effectiveVolume = new Computed(
- *   state,
- *   ['volume', 'muted'],
- *   ({ volume, muted }) => muted ? 0 : volume
- * );
- *
- * effectiveVolume.current;  // derived value
- * effectiveVolume.subscribe(() => console.log('changed'));
- * effectiveVolume.destroy();  // cleanup when done
- * ```
- */
-export class Computed<T extends object, K extends keyof T, R> {
-  readonly #state: State<T>;
-  readonly #keys: K[];
-  readonly #derive: (snapshot: Pick<T, K>) => R;
-  readonly #listeners = new Set<() => void>();
-  readonly #unsubscribe: () => void;
-
-  #cached!: R;
-  #initialized = false;
-
-  constructor(state: State<T>, keys: K[], derive: (snapshot: Pick<T, K>) => R) {
-    this.#state = state;
-    this.#keys = keys;
-    this.#derive = derive;
-
-    this.#unsubscribe = state.subscribe(keys, () => {
-      if (this.#compute()) {
-        for (const fn of this.#listeners) fn();
-      }
-    });
-  }
-
-  get current(): R {
-    if (!this.#initialized) this.#compute();
-    return this.#cached;
-  }
-
-  subscribe(callback: () => void): () => void {
-    this.#listeners.add(callback);
-    return () => this.#listeners.delete(callback);
-  }
-
-  destroy(): void {
-    this.#unsubscribe();
-    this.#listeners.clear();
-  }
-
-  #compute(): boolean {
-    const currentState = {} as Pick<T, K>;
-
-    for (const k of this.#keys) {
-      currentState[k] = this.#state.current[k];
-    }
-
-    const next = this.#derive(currentState);
-    const changed = !this.#initialized || !Object.is(this.#cached, next);
-
-    this.#cached = next;
-    this.#initialized = true;
-
-    return changed;
-  }
-}
diff --git a/packages/store/src/core/config.ts b/packages/store/src/core/config.ts
new file mode 100644
index 00000000..6e4f1bb7
--- /dev/null
+++ b/packages/store/src/core/config.ts
@@ -0,0 +1,40 @@
+import type { AnyFeature, UnionFeatureTarget } from './feature';
+import type { TaskKey } from './queue';
+import type { RequestMeta } from './request';
+import type { Store } from './store';
+
+export interface PendingTask {
+  key: TaskKey;
+  meta: RequestMeta | null;
+  startedAt: number;
+}
+
+export interface StoreConfig<Features extends AnyFeature[]> {
+  features: Features;
+  onSetup?: (ctx: StoreSetupContext<Features>) => void;
+  onAttach?: (ctx: StoreAttachContext<Features>) => void;
+  onError?: (ctx: StoreErrorContext<Features>) => void;
+  onTaskStart?: (ctx: StoreTaskContext) => void;
+  onTaskEnd?: (ctx: StoreTaskContext & { error?: unknown }) => void;
+}
+
+export interface StoreSetupContext<Features extends AnyFeature[]> {
+  store: Store<Features>;
+  signal: AbortSignal;
+}
+
+export interface StoreAttachContext<Features extends AnyFeature[]> {
+  store: Store<Features>;
+  target: UnionFeatureTarget<Features>;
+  signal: AbortSignal;
+}
+
+export interface StoreErrorContext<Features extends AnyFeature[]> {
+  store: Store<Features>;
+  error: unknown;
+}
+
+export interface StoreTaskContext {
+  key: TaskKey;
+  meta: RequestMeta | null;
+}
diff --git a/packages/store/src/core/errors.ts b/packages/store/src/core/errors.ts
index a177bb82..ed9b14db 100644
--- a/packages/store/src/core/errors.ts
+++ b/packages/store/src/core/errors.ts
@@ -8,30 +8,22 @@
  *     case 'SUPERSEDED':
  *       // Request was replaced by another - expected behavior
  *       break;
- *     case 'REJECTED':
- *       // Guard condition failed
+ *     case 'ABORTED':
+ *       // Request was aborted
  *       break;
  *   }
  * }
  * ```
  */
 export type StoreErrorCode =
-  /** Request was aborted via AbortSignal - user or system requested cancellation. */
+  /** Request was aborted via AbortSignal. */
   | 'ABORTED'
-  /** Request was cancelled by another request's `cancel` configuration. */
-  | 'CANCELLED'
-  /** Store or queue was destroyed - lifecycle ended. */
+  /** Store or queue was destroyed. */
   | 'DESTROYED'
-  /** Target was detached while request was in flight. */
-  | 'DETACHED'
   /** No target is attached to the store. */
   | 'NO_TARGET'
-  /** Guard condition returned falsy - request preconditions not met. */
-  | 'REJECTED'
   /** Request was replaced by a newer request with the same key. */
-  | 'SUPERSEDED'
-  /** Guard condition timed out waiting for a truthy result. */
-  | 'TIMEOUT';
+  | 'SUPERSEDED';
 
 export interface StoreErrorOptions {
   cause?: unknown;
diff --git a/packages/store/src/core/feature.ts b/packages/store/src/core/feature.ts
index 037a4cbd..0fd00963 100644
--- a/packages/store/src/core/feature.ts
+++ b/packages/store/src/core/feature.ts
@@ -1,159 +1,118 @@
-import type { UnionToIntersection } from '@videojs/utils/types';
-import type {
-  Request,
-  RequestConfig,
-  RequestConfigMap,
-  RequestHandler,
-  ResolvedRequestConfigMap,
-  ResolveRequestHandler,
-  ResolveRequestMap,
-} from './request';
+import { isObject } from '@videojs/utils/predicate';
+import type { Simplify, UnionToIntersection } from '@videojs/utils/types';
+import type { TaskKey, TaskMode } from './queue';
+import type { RequestMeta } from './request';
 
-import { resolveRequests } from './request';
+const FEATURE_SYMBOL = Symbol('@videojs/feature');
 
 // ----------------------------------------
-// Types
+// Task
 // ----------------------------------------
 
-export type AnyFeature<Target = any> = Feature<Target, any, any>;
+export type Task<Target, State extends object> = {
+  <Output>(handler: TaskHandler<Target, State, Output>): Promise<Awaited<Output>>;
+  <Output>(options: TaskOptions<Target, State, Output>): Promise<Awaited<Output>>;
+};
 
-export interface Feature<Target, State extends object, Requests extends { [K in keyof Requests]: Request<any, any> }> {
-  readonly id: symbol;
-  readonly initialState: State;
-  readonly getSnapshot: FeatureGetSnapshot<Target, State>;
-  readonly subscribe: FeatureSubscribe<Target, State>;
-  readonly request: ResolvedRequestConfigMap<Target, Requests>;
+export interface TaskOptions<Target, State extends object, Output> {
+  key?: TaskKey;
+  mode?: TaskMode;
+  cancels?: TaskKey[];
+  handler: TaskHandler<Target, State, Output>;
 }
 
-export type FeatureGetSnapshot<Target, State> = (ctx: FeatureGetSnapshotContext<Target, State>) => State;
+export type TaskHandler<Target, State extends object, Output> = (ctx: TaskContext<Target, State>) => Output;
 
-export interface FeatureGetSnapshotContext<Target, State> {
+export interface TaskContext<Target, State extends object> {
   target: Target;
-  initialState: State;
-}
-
-export type FeatureSubscribe<Target, State extends object> = (ctx: FeatureSubscribeContext<Target, State>) => void;
-
-export interface FeatureSubscribeContext<Target, _State extends object> {
-  target: Target;
-  update: FeatureUpdate;
   signal: AbortSignal;
-}
-
-/** Sync feature state from target via getSnapshot. */
-export type FeatureUpdate = () => void;
-
-export interface FeatureConfig<
-  Target,
-  State extends object,
-  Requests extends { [K in keyof Requests]: Request<any, any> },
-> {
-  initialState: State;
-  getSnapshot: FeatureGetSnapshot<Target, State>;
-  subscribe: FeatureSubscribe<Target, State>;
-  request: RequestConfigMap<Target, Requests>;
+  get: () => Readonly<State>;
+  meta: RequestMeta | null;
 }
 
 // ----------------------------------------
-// Type Inference
+// Sync Config
 // ----------------------------------------
 
-export type InferFeatureTarget<S> = S extends Feature<infer T, any, any> ? T : never;
+export type GetSnapshot<Target, State extends object> = (ctx: GetSnapshotContext<Target, State>) => Partial<State>;
 
-export type InferFeatureState<S> = S extends Feature<any, infer State, any> ? State : never;
+export interface GetSnapshotContext<Target, State extends object> {
+  target: Target;
+  get: () => Readonly<State>;
+  initialState: Readonly<State>;
+}
 
-export type InferFeatureRequests<S> = S extends Feature<any, any, infer R> ? { [K in keyof R]: R[K] } : never;
+export type Subscribe<Target, State extends object> = (ctx: SubscribeContext<Target, State>) => void;
 
-export type ResolveFeatureRequestHandlers<S> =
-  S extends Feature<any, any, infer R> ? { [K in keyof R]: ResolveRequestHandler<R[K]> } : never;
+export interface SubscribeContext<Target, State extends object> {
+  target: Target;
+  update: () => void;
+  signal: AbortSignal;
+  get: () => Readonly<State>;
+}
+
+// ----------------------------------------
+// Feature Context
+// ----------------------------------------
+
+export interface FeatureContext<Target, State extends object> {
+  task: Task<Target, State>;
+  get: () => Readonly<State>;
+  target: () => Target;
+}
+
+/** Context passed to state factory - uses loose types to enable State inference. */
+export interface StateFactoryContext<Target> {
+  task: Task<Target, any>;
+  get: () => Readonly<object>;
+  target: () => Target;
+}
+
+// ----------------------------------------
+// Feature
+// ----------------------------------------
+
+export type StateFactory<Target, State extends object> = (ctx: StateFactoryContext<Target>) => State;
+
+export interface FeatureConfig<Target, State extends object> {
+  state: StateFactory<Target, State>;
+  getSnapshot: GetSnapshot<Target, State>;
+  subscribe: Subscribe<Target, State>;
+}
+
+export interface Feature<Target, State extends object> extends FeatureConfig<Target, State> {
+  [FEATURE_SYMBOL]: true;
+}
+
+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> => ({
+    [FEATURE_SYMBOL]: true,
+    ...config,
+  });
+}
+
+export function isFeature(value: unknown): value is AnyFeature {
+  return isObject(value) && FEATURE_SYMBOL in value;
+}
+
+// ----------------------------------------
+// Inference
+// ----------------------------------------
+
+export type InferFeatureTarget<F> = F extends Feature<infer Target, any> ? Target : never;
+
+export type InferFeatureState<F> = F extends Feature<any, infer State> ? State : never;
 
 export type UnionFeatureTarget<Features extends AnyFeature[]> = InferFeatureTarget<Features[number]>;
 
-export type UnionFeatureState<Features extends Feature<any, any, any>[]> = UnionToIntersection<
-  InferFeatureState<Features[number]>
+export type UnionFeatureState<Features extends AnyFeature[]> = Simplify<
+  UnionToIntersection<InferFeatureState<Features[number]>>
 >;
-
-export type UnionFeatureRequests<Features extends Feature<any, any, any>[]> = UnionToIntersection<
-  ResolveFeatureRequestHandlers<Features[number]>
->;
-
-// ----------------------------------------
-// createFeature
-// ----------------------------------------
-
-export type FeatureFactory<Target> = <
-  State extends object,
-  const Requests extends Record<string, RequestHandler<Target, any, any> | RequestConfig<Target, any, any>>,
->(config: {
-  initialState: State;
-  getSnapshot: (ctx: FeatureGetSnapshotContext<Target, State>) => State;
-  subscribe: (ctx: FeatureSubscribeContext<Target, State>) => void;
-  request: Requests;
-}) => Feature<Target, State, ResolveRequestMap<Requests>>;
-
-export type FeatureFactoryResult<Target, Config> = Config extends {
-  initialState: infer S extends object;
-  request: infer R;
-}
-  ? Feature<Target, S, ResolveRequestMap<R>>
-  : never;
-
-/**
- * Create a feature for a target type.
- *
- * @example
- * // Curried form - infers state and requests from config
- * const audioFeature = createFeature<HTMLVideoElement>()({
- *   ...
- * });
- *
- * @example
- * // Explicit types
- * interface AudioState {
- *   volume: number;
- *   muted: boolean
- * }
- *
- * interface AudioRequests {
- *   setVolume: Request<number>;
- *   setMuted: Request<boolean>;
- * }
- * const audioFeature = createFeature<HTMLVideoElement, AudioState, AudioRequests>({...});
- */
-export function createFeature<Target>(): FeatureFactory<Target>;
-
-export function createFeature<
-  Target,
-  State extends object,
-  Requests extends { [K in keyof Requests]: Request<any, any> },
->(config: FeatureConfig<Target, State, Requests>): Feature<Target, State, Requests>;
-
-export function createFeature<
-  Target,
-  State extends object = any,
-  Requests extends { [K in keyof Requests]: Request<any, any> } = any,
->(config?: FeatureConfig<Target, State, Requests>): Feature<Target, State, Requests> | FeatureFactory<Target> {
-  if (arguments.length === 0) {
-    return (<
-      S extends object,
-      const R extends Record<string, RequestHandler<Target, any, any> | RequestConfig<Target, any, any>>,
-    >(config: {
-      initialState: S;
-      getSnapshot: (ctx: FeatureGetSnapshotContext<Target, S>) => S;
-      subscribe: (ctx: FeatureSubscribeContext<Target, S>) => void;
-      request: R;
-    }) => _createFeature(config)) as FeatureFactory<Target>;
-  }
-
-  return _createFeature(config!);
-}
-
-function _createFeature<Target, State extends object, Requests extends { [K in keyof Requests]: Request<any, any> }>(
-  config: FeatureConfig<Target, State, Requests>
-): Feature<Target, State, Requests> {
-  return {
-    id: Symbol('@videojs/feature'),
-    ...config,
-    request: resolveRequests(config.request),
-  };
-}
diff --git a/packages/store/src/core/guard.ts b/packages/store/src/core/guard.ts
deleted file mode 100644
index 1e6643f9..00000000
--- a/packages/store/src/core/guard.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * Result of a guard check.
- *
- * - Truthy → proceed
- * - Falsy → cancel
- * - Promise resolves truthy → proceed
- * - Promise resolves falsy → cancel
- * - Promise rejects → cancel
- */
-export type GuardResult = boolean | Promise<unknown>;
-
-/**
- * Context passed to guard functions.
- */
-export interface GuardContext<Target> {
-  target: Target;
-  signal: AbortSignal;
-}
-
-/**
- * A guard gates request execution.
- */
-export type Guard<Target> = (ctx: GuardContext<Target>) => GuardResult;
diff --git a/packages/store/src/core/index.ts b/packages/store/src/core/index.ts
index 712129af..e923d82f 100644
--- a/packages/store/src/core/index.ts
+++ b/packages/store/src/core/index.ts
@@ -1,8 +1,8 @@
-export * from './computed';
+export * from './config';
 export * from './errors';
 export * from './feature';
-export type { Guard, GuardContext, GuardResult } from './guard';
-export type { TaskKey } from './queue';
+export type { TaskKey, TaskMode } from './queue';
+export { CANCEL_ALL } from './queue';
 export * from './request';
 export * from './state';
 export * from './store';
diff --git a/packages/store/src/core/queue.ts b/packages/store/src/core/queue.ts
index 71e444b1..4c320e2e 100644
--- a/packages/store/src/core/queue.ts
+++ b/packages/store/src/core/queue.ts
@@ -1,6 +1,8 @@
 import { abortable } from '@videojs/utils/events';
 import { StoreError } from './errors';
-import type { RequestMode } from './request';
+
+/** Cancel all pending tasks (nuclear reset). */
+export const CANCEL_ALL = Symbol.for('@videojs/cancel-all');
 
 // ----------------------------------------
 // Types
@@ -8,9 +10,11 @@ import type { RequestMode } from './request';
 
 export type TaskKey = string | symbol;
 
+export type TaskMode = 'exclusive' | 'shared';
+
 export interface QueueTask<Output = unknown> {
   key: TaskKey;
-  mode?: RequestMode;
+  mode?: TaskMode;
   handler: (ctx: { signal: AbortSignal }) => Promise<Output>;
 }
 
diff --git a/packages/store/src/core/request.ts b/packages/store/src/core/request.ts
index 48a4b265..b3888fe9 100644
--- a/packages/store/src/core/request.ts
+++ b/packages/store/src/core/request.ts
@@ -1,159 +1,8 @@
 import type { EventLike } from '@videojs/utils/events';
-import { isFunction, isObject } from '@videojs/utils/predicate';
-import type { Guard } from './guard';
-import type { TaskKey } from './queue';
-
-// ----------------------------------------
-// Symbols
-// ----------------------------------------
+import { isObject } from '@videojs/utils/predicate';
 
 export const REQUEST_META = Symbol.for('@videojs/request');
 
-/** Cancel all pending requests when this request is enqueued. Like native `load()`. */
-export const CANCEL_ALL = Symbol.for('@videojs/cancel-all');
-
-// ----------------------------------------
-// Types
-// ----------------------------------------
-
-export interface Request<Input = void, Output = void> {
-  input: Input;
-  output: Output;
-}
-
-export type RequestRecord = {
-  [K in string]: Request<any, any>;
-};
-
-export type DefaultRequestRecord = Record<string, Request>;
-
-export interface RequestContext<Target> {
-  target: Target;
-  signal: AbortSignal;
-  meta: RequestMeta | null;
-}
-
-export type RequestKey<Input = unknown> = TaskKey | ((input: Input) => TaskKey);
-
-export type RequestMode = 'exclusive' | 'shared';
-
-export type RequestCancel<Input = unknown> =
-  | typeof CANCEL_ALL
-  | TaskKey
-  | TaskKey[]
-  | ((input: Input) => typeof CANCEL_ALL | TaskKey | TaskKey[]);
-
-export type RequestHandler<Target, Input = unknown, Output = unknown> = (
-  input: Input,
-  ctx: RequestContext<Target>
-) => Output | Promise<Output>;
-
-export interface RequestConfig<Target, Input = unknown, Output = unknown> {
-  key?: RequestKey<Input>;
-  mode?: RequestMode;
-  guard?: Guard<Target> | Guard<Target>[];
-  cancel?: RequestCancel<Input>;
-  handler: RequestHandler<Target, Input, Output>;
-}
-
-export interface ResolvedRequestConfig<Target, Input = unknown, Output = unknown> {
-  key: RequestKey<Input>;
-  mode: RequestMode;
-  guard: Guard<Target>[];
-  cancel?: RequestCancel<Input> | undefined;
-  handler: RequestHandler<Target, Input, Output>;
-}
-
-export type RequestHandlerRecord = {
-  [K in string]: RequestHandler<any, any, any>;
-};
-
-export type RequestConfigMap<Target, Requests extends { [K in keyof Requests]: Request<any, any> }> = {
-  [K in keyof Requests]: Requests[K] extends Request<infer I, infer O>
-    ? RequestHandler<Target, I, O> | RequestConfig<Target, I, O>
-    : never;
-};
-
-export type ResolvedRequestConfigMap<Target, Requests extends { [K in keyof Requests]: Request<any, any> }> = {
-  [K in keyof Requests]: Requests[K] extends Request<infer I, infer O> ? ResolvedRequestConfig<Target, I, O> : never;
-};
-
-// ----------------------------------------
-// Type Inference
-// ----------------------------------------
-
-export type InferRequestHandlerInput<Handler> = Handler extends () => any
-  ? void
-  : Handler extends (input: infer I, ctx?: any) => any
-    ? I
-    : Handler extends { handler: () => any }
-      ? void
-      : Handler extends { handler: (input: infer I, ctx?: any) => any }
-        ? I
-        : void;
-
-export type InferRequestHandlerOutput<Handler> = Handler extends (...args: any[]) => infer O
-  ? Awaited<O>
-  : Handler extends { handler: (...args: any[]) => infer O }
-    ? Awaited<O>
-    : void;
-
-export type ResolveRequestMap<Requests> = {
-  [K in keyof Requests]: Request<InferRequestHandlerInput<Requests[K]>, InferRequestHandlerOutput<Requests[K]>>;
-};
-
-export type ResolveRequestHandler<R> =
-  R extends Request<infer I, infer O>
-    ? [I] extends [void | undefined]
-      ? (input?: undefined, meta?: RequestMetaInit) => Promise<O>
-      : (input: I, meta?: RequestMetaInit) => Promise<O>
-    : never;
-
-// ----------------------------------------
-// Utilities
-// ----------------------------------------
-
-export function resolveRequests<Target, Requests extends { [K in keyof Requests]: Request<any, any> }>(
-  requests: RequestConfigMap<Target, Requests>
-): ResolvedRequestConfigMap<Target, Requests> {
-  const resolved: Record<string, ResolvedRequestConfig<Target>> = {};
-
-  for (const [name, config] of Object.entries(requests) as [string, RequestHandler<Target> | RequestConfig<Target>][]) {
-    if (isFunction(config)) {
-      resolved[name] = {
-        key: name,
-        mode: 'exclusive',
-        guard: [],
-        handler: config,
-      };
-    } else {
-      resolved[name] = {
-        key: config.key ?? name,
-        mode: config.mode ?? 'exclusive',
-        cancel: config.cancel,
-        handler: config.handler,
-        guard: config.guard ? (Array.isArray(config.guard) ? config.guard : [config.guard]) : [],
-      };
-    }
-  }
-
-  return resolved as ResolvedRequestConfigMap<Target, Requests>;
-}
-
-export function resolveRequestKey(keyConfig: RequestKey<any>, input: unknown): TaskKey {
-  return isFunction(keyConfig) ? keyConfig(input) : keyConfig;
-}
-
-export function resolveRequestCancel(
-  cancel: RequestCancel<any> | undefined,
-  input: unknown
-): typeof CANCEL_ALL | TaskKey[] {
-  if (!cancel) return [];
-  const result = isFunction(cancel) ? cancel(input) : cancel;
-  if (result === CANCEL_ALL) return CANCEL_ALL;
-  return Array.isArray(result) ? result : [result];
-}
-
 // ----------------------------------------
 // Request Meta
 // ----------------------------------------
diff --git a/packages/store/src/core/state.ts b/packages/store/src/core/state.ts
index 37e0387f..54193a20 100644
--- a/packages/store/src/core/state.ts
+++ b/packages/store/src/core/state.ts
@@ -2,7 +2,6 @@ export type StateChange = () => void;
 
 export interface State<T extends object> {
   readonly current: Readonly<T>;
-  subscribe<K extends keyof T>(keys: K[], callback: StateChange): () => void;
   subscribe(callback: StateChange): () => void;
 }
 
@@ -20,7 +19,7 @@ function scheduleFlush(): void {
   queueMicrotask(flush);
 }
 
-const pendingContainers = new Set<StateContainer<any, any>>();
+const pendingContainers = new Set<StateContainer<any>>();
 
 export function flush(): void {
   flushScheduled = false;
@@ -34,11 +33,10 @@ export function flush(): void {
 
 const hasOwnProp = Object.prototype.hasOwnProperty;
 
-class StateContainer<T extends object, K extends keyof T> implements WritableState<T> {
+class StateContainer<T extends object> implements WritableState<T> {
   #current: T;
   #listeners = new Set<StateChange>();
-  #keyListeners = new Map<K, Set<StateChange>>();
-  #pending = new Set<K>();
+  #pending = false;
 
   constructor(initial: T) {
     this.#current = Object.freeze({ ...initial });
@@ -51,22 +49,19 @@ class StateContainer<T extends object, K extends keyof T> implements WritableSta
   set<K extends keyof T>(key: K, value: T[K]): void {
     if (Object.is(this.#current[key], value)) return;
     this.#current = Object.freeze({ ...this.#current, [key]: value });
-    this.#pending.add(key as any);
-    pendingContainers.add(this);
-    scheduleFlush();
+    this.#markPending();
   }
 
   delete<K extends keyof T>(key: K): void {
     if (!(key in this.#current)) return;
     const { [key]: _, ...rest } = this.#current;
     this.#current = Object.freeze(rest as T);
-    this.#pending.add(key as any);
-    pendingContainers.add(this);
-    scheduleFlush();
+    this.#markPending();
   }
 
   patch(partial: Partial<T>): void {
     const next = { ...this.#current };
+    let changed = false;
 
     for (const key in partial) {
       if (!hasOwnProp.call(partial, key)) continue;
@@ -75,60 +70,32 @@ class StateContainer<T extends object, K extends keyof T> implements WritableSta
 
       if (!Object.is(this.#current[key], value)) {
         next[key] = value!;
-        this.#pending.add(key as any);
+        changed = true;
       }
     }
 
-    if (this.#pending.size > 0) {
+    if (changed) {
       this.#current = Object.freeze(next);
-      pendingContainers.add(this);
-      scheduleFlush();
+      this.#markPending();
     }
   }
 
-  subscribe(callback: StateChange): () => void;
-  subscribe<K extends keyof T>(keys: K[], callback: StateChange): () => void;
-  subscribe(first: StateChange | K[], second?: StateChange): () => void {
-    // Key-specific subscription
-    if (Array.isArray(first)) {
-      const keys = first;
-      const callback = second!;
-
-      for (const key of keys) {
-        let set = this.#keyListeners.get(key);
-        if (!set) this.#keyListeners.set(key, (set = new Set()));
-        set.add(callback);
-      }
-
-      return () => {
-        for (const key of keys) {
-          this.#keyListeners.get(key)?.delete(callback);
-        }
-      };
-    }
-
-    // Global subscription
-    const callback = first;
+  subscribe(callback: StateChange): () => void {
     this.#listeners.add(callback);
-
     return () => this.#listeners.delete(callback);
   }
 
   flush(): void {
-    if (this.#pending.size === 0) return;
-
-    const keys = this.#pending;
-    this.#pending = new Set();
+    if (!this.#pending) return;
+    this.#pending = false;
 
     for (const fn of this.#listeners) fn();
+  }
 
-    for (const key of keys) {
-      const set = this.#keyListeners.get(key);
-
-      if (set) {
-        for (const fn of set) fn();
-      }
-    }
+  #markPending(): void {
+    this.#pending = true;
+    pendingContainers.add(this);
+    scheduleFlush();
   }
 }
 
diff --git a/packages/store/src/core/store.ts b/packages/store/src/core/store.ts
index c7faeddc..25d40ff3 100644
--- a/packages/store/src/core/store.ts
+++ b/packages/store/src/core/store.ts
@@ -1,343 +1,304 @@
-import { abortable } from '@videojs/utils/events';
-import { isNull } from '@videojs/utils/predicate';
+import type { EventLike } from '@videojs/utils/events';
+import { isFunction, isNull, isObject } from '@videojs/utils/predicate';
+import type { PendingTask, StoreConfig } from './config';
 import { StoreError } from './errors';
-import type { AnyFeature, FeatureUpdate, UnionFeatureRequests, UnionFeatureState, UnionFeatureTarget } from './feature';
-
-import { Queue } from './queue';
-import type { RequestMeta, RequestMetaInit, ResolvedRequestConfig } from './request';
-import { CANCEL_ALL, createRequestMeta, resolveRequestCancel, resolveRequestKey } from './request';
+import type {
+  AnyFeature,
+  StateFactoryContext,
+  TaskContext,
+  TaskHandler,
+  TaskOptions,
+  UnionFeatureState,
+  UnionFeatureTarget,
+} from './feature';
+import { CANCEL_ALL, Queue } from './queue';
+import type { RequestMeta, RequestMetaInit } from './request';
+import { createRequestMeta, createRequestMetaFromEvent } from './request';
 import type { StateChange, WritableState } from './state';
 import { createState } from './state';
 
-export class Store<Target, Features extends AnyFeature<Target>[] = AnyFeature<Target>[]> {
-  readonly #config: StoreConfig<Target, Features>;
-  readonly #features: Features;
-  readonly #queue: Queue;
-  readonly #request: UnionFeatureRequests<Features>;
-  readonly #requestConfigs: Map<string, ResolvedRequestConfig<Target>>;
-  readonly #setupAbort = new AbortController();
-  readonly #state: WritableState<UnionFeatureState<Features> & object>;
+const STORE_SYMBOL = Symbol('@videojs/store');
 
-  #target: Target | null = null;
-  #attachAbort: AbortController | null = null;
-  #destroyed = false;
+export function createStore<Features extends AnyFeature[]>(config: StoreConfig<Features>): Store<Features> {
+  type Target = UnionFeatureTarget<Features>;
+  type State = UnionFeatureState<Features>;
 
-  constructor(config: StoreConfig<Target, Features>) {
-    this.#config = config;
-    this.#features = config.features;
+  const { features } = config;
 
-    this.#queue = new Queue();
-    this.#state = createState(this.#createInitialState() as UnionFeatureState<Features> & object);
+  // Closure state
+  let target: Target | null = null;
+  let destroyed = false;
+  let attachAbort: AbortController | null = null;
 
-    this.#requestConfigs = this.#buildRequestConfigs();
-    this.#request = this.#buildRequestProxy();
+  const setupAbort = new AbortController();
+  const queue = new Queue();
+  const pending: Record<string, PendingTask> = {};
 
-    try {
-      config.onSetup?.({
-        store: this,
-        signal: this.#setupAbort.signal,
-      });
-    } catch (error) {
-      this.#handleError({ error });
-    }
+  // Reactive state - initialized after building features
+  let state: WritableState<State>;
+
+  const ctx: StateFactoryContext<Target> = {
+    task: executeTask,
+    get: () => state.current,
+    target: () => {
+      if (!target) throw new StoreError('NO_TARGET');
+      return target;
+    },
+  };
+
+  const featureState = buildFeatureState(ctx);
+  state = createState(featureState);
+
+  const store = {
+    [STORE_SYMBOL]: true,
+    get target() {
+      return target;
+    },
+    get destroyed() {
+      return destroyed;
+    },
+    get pending() {
+      return pending;
+    },
+    get state() {
+      return state.current;
+    },
+    attach,
+    destroy,
+    subscribe,
+    meta,
+  } as unknown as Store<Features>;
+
+  for (const key of Object.keys(featureState)) {
+    Object.defineProperty(store, key, {
+      get: () => (state.current as Record<string, unknown>)[key],
+      enumerable: true,
+    });
   }
 
-  // ----------------------------------------
-  // Public Getters
-  // ----------------------------------------
+  // Proxy returned by meta() - wraps action calls to clear currentMeta after invocation
+  let currentMeta: RequestMeta | null = null;
+  const metaProxy = new Proxy(store, {
+    get(obj, prop) {
+      const value = Reflect.get(obj, prop);
 
-  get target(): Target | null {
-    return this.#target;
+      if (!isFunction(value)) return value;
+
+      return (...args: unknown[]) => {
+        try {
+          return (value as (...args: unknown[]) => unknown)(...args);
+        } finally {
+          currentMeta = null;
+        }
+      };
+    },
+  });
+
+  try {
+    config.onSetup?.({ store, signal: setupAbort.signal });
+  } catch (error) {
+    handleError(error);
   }
 
-  /** Current state snapshot. */
-  get state(): Readonly<UnionFeatureState<Features> & object> {
-    return this.#state.current;
-  }
+  return store;
 
-  get request(): UnionFeatureRequests<Features> {
-    return this.#request;
-  }
+  function attach(newTarget: Target): () => void {
+    if (destroyed) throw new StoreError('DESTROYED');
 
-  get features(): Features {
-    return this.#features;
-  }
+    attachAbort?.abort();
+    target = newTarget;
+    attachAbort = new AbortController();
+    const signal = attachAbort.signal;
 
-  get destroyed(): boolean {
-    return this.#destroyed;
-  }
+    state.patch(featureState);
 
-  // ----------------------------------------
-  // Attach / Detach
-  // ----------------------------------------
-
-  attach(newTarget: Target): () => void {
-    if (this.#destroyed) {
-      throw new StoreError('DESTROYED');
-    }
-
-    this.#attachAbort?.abort();
-
-    this.#target = newTarget;
-    this.#attachAbort = new AbortController();
-    const signal = this.#attachAbort.signal;
-
-    this.#resetState();
-
-    for (const feature of this.#features) {
+    for (const feature of features) {
       try {
-        const update = this.#createUpdate(feature);
-        feature.subscribe({ target: newTarget, update, signal });
+        feature.subscribe({
+          target: newTarget,
+          update: () => syncFeature(feature, newTarget),
+          signal,
+          get: () => state.current,
+        });
       } catch (error) {
-        this.#handleError({ error });
+        handleError(error);
       }
     }
 
-    this.#syncAllFeatures();
+    syncAll();
 
     try {
-      this.#config.onAttach?.({
-        store: this,
-        target: newTarget,
-        signal,
-      });
+      config.onAttach?.({ store, target: newTarget, signal });
     } catch (error) {
-      this.#handleError({ error });
+      handleError(error);
     }
 
-    return () => this.#detach();
+    return detach;
   }
 
-  #createUpdate(feature: AnyFeature<Target>): FeatureUpdate {
-    return () => {
-      const target = this.#target;
-      if (target) this.#syncFeature(feature, target);
-    };
+  function detach(): void {
+    if (isNull(target)) return;
+    attachAbort?.abort();
+    attachAbort = null;
+    target = null;
+    queue.abort();
+    state.patch(featureState);
   }
 
-  #detach(): void {
-    if (isNull(this.#target)) return;
-    this.#attachAbort?.abort();
-    this.#attachAbort = null;
-    this.#target = null;
-    this.#queue.abort();
-    this.#resetState();
+  function destroy(): void {
+    if (destroyed) return;
+    destroyed = true;
+    detach();
+    setupAbort.abort();
+    queue.destroy();
   }
 
-  // ----------------------------------------
-  // Destroy
-  // ----------------------------------------
-
-  destroy(): void {
-    if (this.#destroyed) return;
-    this.#destroyed = true;
-    this.#detach();
-    this.#setupAbort.abort();
-    this.#queue.destroy();
+  function subscribe(callback: StateChange): () => void {
+    return state.subscribe(callback);
   }
 
-  // ----------------------------------------
-  // State
-  // ----------------------------------------
-
-  /** Subscribe to state changes. */
-  subscribe(callback: StateChange): () => void;
-
-  subscribe<K extends keyof UnionFeatureState<Features>>(keys: K[], callback: StateChange): () => void;
-
-  subscribe(first: StateChange | (keyof UnionFeatureState<Features>)[], second?: StateChange): () => void {
-    return this.#state.subscribe(first as (keyof UnionFeatureState<Features>)[], second as StateChange);
+  function meta(eventOrMeta: EventLike | RequestMetaInit): Store<Features> {
+    currentMeta =
+      'isTrusted' in eventOrMeta
+        ? createRequestMetaFromEvent(eventOrMeta as EventLike)
+        : createRequestMeta(eventOrMeta as RequestMetaInit);
+    return metaProxy as Store<Features>;
   }
 
-  #syncAllFeatures(): void {
-    const target = this.#target;
+  function buildFeatureState(ctx: StateFactoryContext<Target>): State {
+    const result: Record<string, unknown> = {};
+
+    for (const feature of features) {
+      const featureResult = feature.state(ctx);
+      Object.assign(result, featureResult);
+    }
+
+    return result as State;
+  }
+
+  function syncAll(): void {
     if (!target) return;
-
-    for (const feature of this.#features) {
-      this.#syncFeature(feature, target);
+    for (const feature of features) {
+      syncFeature(feature, target);
     }
   }
 
-  #syncFeature(feature: AnyFeature<Target>, target: Target): void {
+  function syncFeature(feature: AnyFeature<Target>, t: Target): void {
     try {
       const snapshot = feature.getSnapshot({
-        target,
-        initialState: feature.initialState,
+        target: t,
+        get: () => state.current,
+        initialState: featureState,
       });
-
-      this.#state.patch(snapshot);
+      state.patch(snapshot as Partial<State>);
     } catch (error) {
-      this.#handleError({ error });
+      handleError(error);
     }
   }
 
-  #createInitialState(): UnionFeatureState<Features> {
-    const initialState: Record<string, unknown> = {};
+  async function executeTask<Output>(handler: TaskHandler<Target, State, Output>): Promise<Awaited<Output>>;
+  async function executeTask<Output>(options: TaskOptions<Target, State, Output>): Promise<Awaited<Output>>;
+  async function executeTask<Output>(
+    handlerOrOptions: TaskHandler<Target, State, Output> | TaskOptions<Target, State, Output>
+  ): Promise<Awaited<Output>> {
+    if (destroyed) throw new StoreError('DESTROYED');
 
-    for (const feature of this.#features) {
-      Object.assign(initialState, feature.initialState);
-    }
+    const options: TaskOptions<Target, State, Output> = isFunction(handlerOrOptions)
+      ? { handler: handlerOrOptions }
+      : handlerOrOptions;
 
-    return initialState as UnionFeatureState<Features>;
-  }
+    const { key, mode = 'exclusive', cancels, handler } = options;
 
-  #resetState(): void {
-    this.#state.patch(this.#createInitialState() as Partial<UnionFeatureState<Features> & object>);
-  }
+    const meta = currentMeta;
+    currentMeta = null;
 
-  // ----------------------------------------
-  // Requests
-  // ----------------------------------------
-
-  #buildRequestConfigs(): Map<string, ResolvedRequestConfig<Target>> {
-    const configs = new Map<string, ResolvedRequestConfig<Target>>();
-
-    for (const feature of this.#features) {
-      for (const [name, config] of Object.entries(feature.request)) {
-        configs.set(name, config as ResolvedRequestConfig<Target>);
+    if (cancels) {
+      for (const cancelKey of cancels) {
+        if (cancelKey === CANCEL_ALL) {
+          queue.abort();
+        } else {
+          queue.abort(cancelKey);
+        }
       }
     }
 
-    return configs;
-  }
+    if (key) {
+      pending[key as string] = { key, meta, startedAt: Date.now() };
+      config.onTaskStart?.({ key, meta });
+    }
 
-  #buildRequestProxy(): UnionFeatureRequests<Features> {
-    const reqProxy: Record<string, (...args: any[]) => Promise<unknown>> = {};
+    const queueHandler = async ({ signal }: { signal: AbortSignal }) => {
+      if (!target) throw new StoreError('NO_TARGET');
 
-    for (const [name, config] of this.#requestConfigs) {
-      reqProxy[name] = (input?: unknown, meta?: RequestMetaInit) => {
-        if (this.#destroyed) {
-          return Promise.reject(new StoreError('DESTROYED'));
-        }
-
-        return this.#execute(name, config, input, meta ? createRequestMeta(meta) : null);
+      const ctx: TaskContext<Target, State> = {
+        target,
+        signal,
+        get: () => state.current,
+        meta,
       };
-    }
 
-    return reqProxy as UnionFeatureRequests<Features>;
-  }
-
-  async #execute(
-    _name: string,
-    config: ResolvedRequestConfig<Target>,
-    input: unknown,
-    meta: RequestMeta | null
-  ): Promise<unknown> {
-    const key = resolveRequestKey(config.key, input);
-
-    const cancel = resolveRequestCancel(config.cancel, input);
-    if (cancel === CANCEL_ALL) {
-      this.#queue.abort();
-    } else {
-      for (const requestName of cancel) {
-        this.#queue.abort(requestName);
-      }
-    }
-
-    const handler = async ({ signal }: { signal: AbortSignal }) => {
-      const target = this.#target;
-
-      if (!target) {
-        throw new StoreError('NO_TARGET');
-      }
-
-      for (const guard of config.guard) {
-        const result = await abortable(Promise.resolve(guard({ target, signal })), signal);
-
-        if (!result) {
-          throw new StoreError('REJECTED');
-        }
-      }
-
-      return config.handler(input, { target, signal, meta });
+      return handler(ctx);
     };
 
     try {
-      return await this.#queue.enqueue({
-        key,
-        mode: config.mode,
-        handler,
+      const result = await queue.enqueue({
+        key: key ?? Symbol('@videojs/task'),
+        mode,
+        handler: queueHandler,
       });
+
+      if (key) {
+        delete pending[key as string];
+        config.onTaskEnd?.({ key, meta });
+      }
+
+      return result as Awaited<Output>;
     } catch (error) {
-      this.#handleError({ error });
+      if (key) {
+        delete pending[key as string];
+        config.onTaskEnd?.({ key, meta, error });
+      }
+
+      handleError(error);
       throw error;
     }
   }
 
-  // ----------------------------------------
-  // Errors
-  // ----------------------------------------
-
-  #handleError(context: Omit<StoreErrorContext<Target, Features>, 'store'>): void {
-    if (this.#config.onError) {
-      this.#config.onError({ ...context, store: this });
+  function handleError(error: unknown): void {
+    if (config.onError) {
+      config.onError({ store, error });
     } else {
-      console.error('[vjs-store]', context.error);
+      console.error('[vjs-store]', error);
     }
   }
 }
 
 export function isStore(value: unknown): value is AnyStore {
-  return value instanceof Store;
-}
-
-// ----------------------------------------
-// Factory
-// ----------------------------------------
-
-export function createStore<Features extends AnyFeature[]>(
-  config: StoreConfig<UnionFeatureTarget<Features>, Features>
-): Store<UnionFeatureTarget<Features>, Features> {
-  return new Store(config);
+  return isObject(value) && STORE_SYMBOL in value;
 }
 
 // ----------------------------------------
 // Types
 // ----------------------------------------
 
-export type AnyStore<Target = any> = Store<Target, AnyFeature<Target>[]>;
-
-export type AnyStoreConfig = StoreConfig<any, AnyFeature[]>;
-
-export interface StoreConfig<Target, Features extends AnyFeature<Target>[]> {
-  features: Features;
-  onSetup?: (ctx: StoreSetupContext<Target, Features>) => void;
-  onAttach?: (ctx: StoreAttachContext<Target, Features>) => void;
-  onError?: (ctx: StoreErrorContext<Target, Features>) => void;
+export interface StoreAPI<Target, Features extends AnyFeature<Target>[]> {
+  readonly target: Target | null;
+  readonly destroyed: boolean;
+  readonly pending: Readonly<Record<string, PendingTask>>;
+  readonly state: UnionFeatureState<Features>;
+  attach(target: Target): () => void;
+  destroy(): void;
+  subscribe(callback: StateChange): () => void;
+  meta(eventOrMeta: EventLike | RequestMetaInit): this;
 }
 
-export interface StoreSetupContext<Target, Features extends AnyFeature<Target>[]> {
-  store: Store<Target, Features>;
-  signal: AbortSignal;
-}
+export type Store<Features extends AnyFeature[]> = StoreAPI<UnionFeatureTarget<Features>, Features> &
+  UnionFeatureState<Features>;
 
-export interface StoreAttachContext<Target, Features extends AnyFeature<Target>[]> {
-  store: Store<Target, Features>;
-  target: Target;
-  signal: AbortSignal;
-}
+export type AnyStore<Target = any> = StoreAPI<Target, AnyFeature<Target>[]>;
 
-export interface StoreErrorContext<Target, Features extends AnyFeature<Target>[]> {
-  store: Store<Target, Features>;
-  error: unknown;
-}
+export type InferStoreTarget<S extends AnyStore> = S extends StoreAPI<infer Target, any> ? Target : never;
 
-export interface StoreProvider<Features extends AnyFeature[]> {
-  store: Store<UnionFeatureTarget<Features>, Features>;
-}
-
-export interface StoreConsumer<Features extends AnyFeature[]> {
-  readonly store: Store<UnionFeatureTarget<Features>, Features> | null;
-}
-
-// ----------------------------------------
-// Type Inference
-// ----------------------------------------
-
-export type InferStoreTarget<S extends AnyStore> = S extends Store<infer Target> ? Target : never;
-
-export type InferStoreFeatures<S extends AnyStore> = S extends Store<any, infer Features> ? Features : never;
+export type InferStoreFeatures<S extends AnyStore> = S extends StoreAPI<any, infer Features> ? Features : never;
 
 export type InferStoreState<S extends AnyStore> = UnionFeatureState<InferStoreFeatures<S>>;
-
-export type InferStoreRequests<S extends AnyStore> = UnionFeatureRequests<InferStoreFeatures<S>>;
diff --git a/packages/store/src/core/tests/computed.test.ts b/packages/store/src/core/tests/computed.test.ts
deleted file mode 100644
index 16c661e8..00000000
--- a/packages/store/src/core/tests/computed.test.ts
+++ /dev/null
@@ -1,184 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { Computed } from '../computed';
-import { createState, flush } from '../state';
-
-describe('computed', () => {
-  interface TestState {
-    volume: number;
-    muted: boolean;
-    currentTime: number;
-  }
-
-  const createTestState = () =>
-    createState<TestState>({
-      volume: 1,
-      muted: false,
-      currentTime: 0,
-    });
-
-  describe('current', () => {
-    it('returns derived value', () => {
-      const state = createTestState();
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-
-      expect(effectiveVolume.current).toBe(1);
-    });
-
-    it('updates when dependency changes', () => {
-      const state = createTestState();
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-
-      expect(effectiveVolume.current).toBe(1);
-
-      state.set('muted', true);
-      flush();
-
-      expect(effectiveVolume.current).toBe(0);
-    });
-
-    it('updates when volume changes', () => {
-      const state = createTestState();
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-
-      state.set('volume', 0.5);
-      flush();
-
-      expect(effectiveVolume.current).toBe(0.5);
-    });
-
-    it('does not recompute when unrelated keys change', () => {
-      const state = createTestState();
-      const deriveFn = vi.fn(({ volume, muted }: Pick<TestState, 'volume' | 'muted'>) => (muted ? 0 : volume));
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], deriveFn);
-
-      // Initial access triggers first computation
-      void effectiveVolume.current;
-      expect(deriveFn).toHaveBeenCalledTimes(1);
-
-      // Changing unrelated key should not recompute
-      state.set('currentTime', 10);
-      flush();
-
-      void effectiveVolume.current;
-      expect(deriveFn).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe('subscribe', () => {
-    it('notifies when computed value changes', () => {
-      const state = createTestState();
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-      const listener = vi.fn();
-
-      effectiveVolume.subscribe(listener);
-
-      state.set('muted', true);
-      flush();
-
-      expect(listener).toHaveBeenCalledOnce();
-    });
-
-    it('does not notify when computed value stays the same', () => {
-      const state = createTestState();
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-      const listener = vi.fn();
-
-      // Access to initialize
-      void effectiveVolume.current;
-      effectiveVolume.subscribe(listener);
-
-      // Already muted=false, volume=1, effective=1
-      // Setting volume to same value shouldn't even trigger state change
-      state.set('volume', 1);
-      flush();
-
-      expect(listener).not.toHaveBeenCalled();
-    });
-
-    it('does not notify when dependency changes but computed result is same', () => {
-      const state = createTestState();
-      // When muted, effective volume is always 0 regardless of volume value
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-      const listener = vi.fn();
-
-      // Mute first
-      state.set('muted', true);
-      flush();
-
-      // Access to initialize (should be 0)
-      expect(effectiveVolume.current).toBe(0);
-      effectiveVolume.subscribe(listener);
-
-      // Change volume while muted - computed stays 0
-      state.set('volume', 0.5);
-      flush();
-
-      expect(effectiveVolume.current).toBe(0);
-      expect(listener).not.toHaveBeenCalled();
-    });
-
-    it('returns unsubscribe function', () => {
-      const state = createTestState();
-      const effectiveVolume = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => (muted ? 0 : volume));
-      const listener = vi.fn();
-
-      const unsub = effectiveVolume.subscribe(listener);
-
-      state.set('muted', true);
-      flush();
-      expect(listener).toHaveBeenCalledOnce();
-
-      unsub();
-
-      state.set('muted', false);
-      flush();
-      expect(listener).toHaveBeenCalledOnce(); // still 1
-    });
-  });
-
-  describe('edge cases', () => {
-    it('works with single key dependency', () => {
-      const state = createTestState();
-      const doubleVolume = new Computed(state, ['volume'], ({ volume }) => volume * 2);
-
-      expect(doubleVolume.current).toBe(2);
-
-      state.set('volume', 0.5);
-      flush();
-
-      expect(doubleVolume.current).toBe(1);
-    });
-
-    it('handles object return values', () => {
-      const state = createTestState();
-      const volumeInfo = new Computed(state, ['volume', 'muted'], ({ volume, muted }) => ({
-        effective: muted ? 0 : volume,
-        display: muted ? 'Muted' : `${Math.round(volume * 100)}%`,
-      }));
-
-      expect(volumeInfo.current).toEqual({
-        effective: 1,
-        display: '100%',
-      });
-
-      state.set('muted', true);
-      flush();
-
-      expect(volumeInfo.current).toEqual({
-        effective: 0,
-        display: 'Muted',
-      });
-    });
-
-    it('lazy initialization - does not compute until accessed', () => {
-      const state = createTestState();
-      const deriveFn = vi.fn(({ volume }: Pick<TestState, 'volume'>) => volume * 2);
-
-      const _ = new Computed(state, ['volume'], deriveFn);
-      void _; // intentionally unused - testing lazy init
-
-      expect(deriveFn).not.toHaveBeenCalled();
-    });
-  });
-});
diff --git a/packages/store/src/core/tests/errors.test.ts b/packages/store/src/core/tests/errors.test.ts
index 89a84019..f117c0df 100644
--- a/packages/store/src/core/tests/errors.test.ts
+++ b/packages/store/src/core/tests/errors.test.ts
@@ -13,9 +13,9 @@ describe('errors', () => {
     });
 
     it('creates error with code and message', () => {
-      const error = new StoreError('TIMEOUT', { message: 'Timeout: canPlay' });
-      expect(error.code).toBe('TIMEOUT');
-      expect(error.message).toBe('Timeout: canPlay');
+      const error = new StoreError('DESTROYED', { message: 'Store was destroyed' });
+      expect(error.code).toBe('DESTROYED');
+      expect(error.message).toBe('Store was destroyed');
     });
 
     it('supports cause for error chaining', () => {
@@ -27,9 +27,9 @@ describe('errors', () => {
 
     it('supports both message and cause', () => {
       const cause = new Error('original');
-      const error = new StoreError('TIMEOUT', { message: 'Timeout: guard', cause });
-      expect(error.code).toBe('TIMEOUT');
-      expect(error.message).toBe('Timeout: guard');
+      const error = new StoreError('NO_TARGET', { message: 'No target attached', cause });
+      expect(error.code).toBe('NO_TARGET');
+      expect(error.message).toBe('No target attached');
       expect(error.cause).toBe(cause);
     });
   });
@@ -37,7 +37,7 @@ describe('errors', () => {
   describe('type guard', () => {
     it('isStoreError identifies store errors', () => {
       expect(isStoreError(new StoreError('ABORTED'))).toBe(true);
-      expect(isStoreError(new StoreError('REJECTED'))).toBe(true);
+      expect(isStoreError(new StoreError('SUPERSEDED'))).toBe(true);
       expect(isStoreError(new Error('regular'))).toBe(false);
       expect(isStoreError(null)).toBe(false);
     });
diff --git a/packages/store/src/core/tests/feature.test.ts b/packages/store/src/core/tests/feature.test.ts
index 76f93dd5..8b46f8dd 100644
--- a/packages/store/src/core/tests/feature.test.ts
+++ b/packages/store/src/core/tests/feature.test.ts
@@ -1,69 +1,137 @@
 import { describe, expect, it, vi } from 'vitest';
 
-import { createFeature } from '../feature';
+import { defineFeature, isFeature } from '../feature';
 
-describe('feature', () => {
-  describe('createFeature', () => {
-    it('creates feature with all required properties', () => {
-      interface Target {
-        value: number;
-      }
+describe('defineFeature', () => {
+  it('creates feature with create function and config', () => {
+    interface Target {
+      value: number;
+    }
 
-      const feature = createFeature<Target>()({
-        initialState: { count: 0 },
-        getSnapshot: ({ target }) => ({ count: target.value }),
-        subscribe: vi.fn(),
-        request: {
-          increment: (amount: number, { target }) => {
-            target.value += amount;
-          },
+    const feature = defineFeature<Target>()({
+      state: ({ task, target }) => ({
+        // State
+        count: 0,
+        // Actions
+        increment(amount: number) {
+          target().value += amount;
         },
-      });
-
-      expect(feature.id).toBeTypeOf('symbol');
-      expect(feature.initialState).toEqual({ count: 0 });
-      expect(feature.getSnapshot).toBeTypeOf('function');
-      expect(feature.subscribe).toBeTypeOf('function');
-      expect(feature.request.increment).toMatchObject({
-        key: 'increment',
-        guard: [],
-        handler: expect.any(Function),
-      });
+        asyncIncrement(amount: number) {
+          return task({
+            key: 'increment',
+            handler: ({ target }) => {
+              target.value += amount;
+            },
+          });
+        },
+      }),
+      getSnapshot: ({ target }) => ({ count: target.value }),
+      subscribe: vi.fn(),
     });
 
-    it('resolves shorthand handlers', () => {
-      const feature = createFeature({
-        initialState: {},
-        getSnapshot: () => ({}),
-        subscribe: () => {},
-        request: {
-          simple: () => 'result',
-        },
-      });
+    expect(feature.state).toBeTypeOf('function');
+    expect(feature.getSnapshot).toBeTypeOf('function');
+    expect(feature.subscribe).toBeTypeOf('function');
+  });
 
-      expect(feature.request.simple.key).toBe('simple');
-      expect(feature.request.simple.guard).toEqual([]);
-      expect(feature.request.simple.cancel).toBeUndefined();
+  it('factory receives task, get, and target helpers', () => {
+    interface Target {
+      value: number;
+    }
+
+    const factorySpy = vi.fn().mockReturnValue({ count: 0 });
+
+    defineFeature<Target>()({
+      state: factorySpy,
+      getSnapshot: () => ({ count: 0 }),
+      subscribe: () => {},
     });
 
-    it('preserves full config options', () => {
-      const guard = () => true;
+    // Can't call the factory directly, but we can verify the shape
+    // The factory will be called by the store when building features
+    expect(factorySpy).not.toHaveBeenCalled();
+  });
 
-      const feature = createFeature({
-        initialState: {},
-        getSnapshot: () => ({}),
-        subscribe: () => {},
-        request: {
-          configured: {
-            key: 'custom-key',
-            guard: [guard],
-            handler: () => {},
-          },
+  it('allows sync actions using target()', () => {
+    interface Target {
+      volume: number;
+    }
+
+    const feature = defineFeature<Target>()({
+      state: ({ target }) => ({
+        volume: 1,
+        setVolume(value: number) {
+          target().volume = value;
         },
-      });
-
-      expect(feature.request.configured.key).toBe('custom-key');
-      expect(feature.request.configured.guard).toEqual([guard]);
+      }),
+      getSnapshot: ({ target }) => ({ volume: target.volume }),
+      subscribe: () => {},
     });
+
+    expect(feature.state).toBeTypeOf('function');
+  });
+
+  it('allows async actions using task()', () => {
+    interface Target {
+      play: () => Promise<void>;
+    }
+
+    const feature = defineFeature<Target>()({
+      state: ({ task }) => ({
+        playing: false,
+        play() {
+          return task({
+            key: 'playback',
+            handler: ({ target }) => target.play(),
+          });
+        },
+      }),
+      getSnapshot: () => ({ playing: false }),
+      subscribe: () => {},
+    });
+
+    expect(feature.state).toBeTypeOf('function');
+  });
+
+  it('supports task shorthand (fire-and-forget)', () => {
+    interface Target {
+      src: string;
+      load: () => void;
+    }
+
+    const feature = defineFeature<Target>()({
+      state: ({ task }) => ({
+        loading: false,
+        load(src: string) {
+          return task(({ target }) => {
+            target.src = src;
+            target.load();
+          });
+        },
+      }),
+      getSnapshot: () => ({ loading: false }),
+      subscribe: () => {},
+    });
+
+    expect(feature.state).toBeTypeOf('function');
+  });
+});
+
+describe('isFeature', () => {
+  it('returns true for features created with defineFeature', () => {
+    const feature = defineFeature<HTMLVideoElement>()({
+      state: () => ({ playing: false }),
+      getSnapshot: () => ({ playing: false }),
+      subscribe: () => {},
+    });
+
+    expect(isFeature(feature)).toBe(true);
+  });
+
+  it('returns false for non-feature objects', () => {
+    expect(isFeature({})).toBe(false);
+    expect(isFeature(null)).toBe(false);
+    expect(isFeature(undefined)).toBe(false);
+    expect(isFeature({ create: () => {} })).toBe(false);
   });
 });
diff --git a/packages/store/src/core/tests/feature.types.test.ts b/packages/store/src/core/tests/feature.types.test.ts
deleted file mode 100644
index b6996fac..00000000
--- a/packages/store/src/core/tests/feature.types.test.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import type { Feature, InferFeatureRequests, InferFeatureState } from '../feature';
-
-import { createFeature } from '../feature';
-
-interface MockTarget {
-  volume: number;
-  muted: boolean;
-}
-
-describe('feature types', () => {
-  describe('createFeature', () => {
-    it('returns Feature type with inferred state', () => {
-      const feature = createFeature<MockTarget>()({
-        initialState: { volume: 1, muted: false },
-        getSnapshot: ({ target }) => ({ volume: target.volume, muted: target.muted }),
-        subscribe: () => {},
-        request: {},
-      });
-
-      expectTypeOf(feature).toExtend<
-        Feature<
-          MockTarget,
-          {
-            volume: number;
-            muted: boolean;
-          },
-          object
-        >
-      >();
-    });
-
-    it('infers request handler types from simple handlers', () => {
-      const _feature = createFeature<MockTarget>()({
-        initialState: { volume: 1 },
-        getSnapshot: ({ target }) => ({ volume: target.volume }),
-        subscribe: () => {},
-        request: {
-          setVolume: (volume: number, { target }) => {
-            target.volume = volume;
-            return volume;
-          },
-        },
-      });
-
-      type Requests = InferFeatureRequests<typeof _feature>;
-
-      expectTypeOf<Requests>().toHaveProperty('setVolume');
-
-      expectTypeOf<Requests['setVolume']>().toExtend<{ input: number; output: number }>();
-    });
-
-    it('infers async request handler types', () => {
-      const _feature = createFeature<MockTarget>()({
-        initialState: { volume: 1 },
-        getSnapshot: ({ target }) => ({ volume: target.volume }),
-        subscribe: () => {},
-        request: {
-          asyncSetVolume: async (volume: number, { target }): Promise<number> => {
-            target.volume = volume;
-            return volume;
-          },
-        },
-      });
-
-      type Requests = InferFeatureRequests<typeof _feature>;
-
-      expectTypeOf<Requests['asyncSetVolume']>().toExtend<{ input: number; output: number }>();
-    });
-
-    it('infers request config with custom key', () => {
-      const _feature = createFeature<MockTarget>()({
-        initialState: { volume: 1, muted: false },
-        getSnapshot: ({ target }) => ({ volume: target.volume, muted: target.muted }),
-        subscribe: () => {},
-        request: {
-          setVolume: {
-            key: 'audio',
-            handler: (volume: number, { target }) => {
-              target.volume = volume;
-              return volume;
-            },
-          },
-          setMuted: {
-            key: 'audio',
-            handler: (muted: boolean, { target }) => {
-              target.muted = muted;
-              return muted;
-            },
-          },
-        },
-      });
-
-      type Requests = InferFeatureRequests<typeof _feature>;
-
-      expectTypeOf<Requests['setVolume']>().toExtend<{ input: number; output: number }>();
-      expectTypeOf<Requests['setMuted']>().toExtend<{ input: boolean; output: boolean }>();
-    });
-
-    it('infers void input when handler takes no arguments', () => {
-      const _feature = createFeature<MockTarget>()({
-        initialState: { muted: false },
-        getSnapshot: ({ target }) => ({ muted: target.muted }),
-        subscribe: () => {},
-        request: {
-          toggleMute: ({ target }) => {
-            target.muted = !target.muted;
-            return target.muted;
-          },
-        },
-      });
-
-      type Requests = InferFeatureRequests<typeof _feature>;
-
-      expectTypeOf<Requests['toggleMute']>().toExtend<{ input: void; output: boolean }>();
-    });
-  });
-
-  describe('InferFeatureState', () => {
-    it('extracts state type from feature', () => {
-      const _feature = createFeature<MockTarget>()({
-        initialState: { volume: 1, muted: false, label: 'test' },
-        getSnapshot: ({ initialState }) => initialState,
-        subscribe: () => {},
-        request: {},
-      });
-
-      type State = InferFeatureState<typeof _feature>;
-
-      expectTypeOf<State>().toEqualTypeOf<{ volume: number; muted: boolean; label: string }>();
-    });
-  });
-
-  describe('InferFeatureRequests', () => {
-    it('extracts request types from feature', () => {
-      const _feature = createFeature<MockTarget>()({
-        initialState: { volume: 1 },
-        getSnapshot: ({ target }) => ({ volume: target.volume }),
-        subscribe: () => {},
-        request: {
-          setVolume: (v: number) => v,
-          reset: () => 1,
-        },
-      });
-
-      type Requests = InferFeatureRequests<typeof _feature>;
-
-      expectTypeOf<Requests>().toHaveProperty('setVolume');
-      expectTypeOf<Requests>().toHaveProperty('reset');
-    });
-  });
-});
diff --git a/packages/store/src/core/tests/integration/store.test.ts b/packages/store/src/core/tests/integration/store.test.ts
index 5128f633..b1c774d5 100644
--- a/packages/store/src/core/tests/integration/store.test.ts
+++ b/packages/store/src/core/tests/integration/store.test.ts
@@ -1,7 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { CANCEL_ALL, createFeature, createStore } from '../../index';
-import { flush } from '../../state';
+import { createStore, defineFeature } from '../../index';
 
 describe('store lifecycle integration', () => {
   it('full lifecycle: create → attach → use → detach → destroy', async () => {
@@ -11,23 +10,26 @@ describe('store lifecycle integration', () => {
       value = 0;
     }
 
-    const feature = createFeature<Target>()({
-      initialState: { count: 0 },
-      getSnapshot: ({ target }) => ({ count: target.value }),
-      subscribe: ({ target, update, signal }) => {
-        events.push('subscribe');
-        target.addEventListener('change', update, { signal });
-        signal.addEventListener('abort', () => events.push('unsubscribe'));
-      },
-      request: {
-        increment: (_, { target }) => {
-          target.value++;
-          target.dispatchEvent(new Event('change'));
-          events.push('increment');
+    const feature = defineFeature<Target>()({
+      state: ({ task }) => ({
+        count: 0,
+        increment() {
+          return task(({ target: t }) => {
+            t.value++;
+            t.dispatchEvent(new Event('change'));
+            events.push('increment');
+          });
         },
+      }),
+      getSnapshot: ({ target: t }) => ({ count: t.value }),
+      subscribe: ({ target: t, update, signal }) => {
+        events.push('subscribe');
+        t.addEventListener('change', update, { signal });
+        signal.addEventListener('abort', () => events.push('unsubscribe'));
       },
     });
 
+    // Cast to any for test access to dynamic properties
     const store = createStore({
       features: [feature],
       onSetup: () => events.push('setup'),
@@ -36,14 +38,14 @@ describe('store lifecycle integration', () => {
 
     expect(events).toEqual(['setup']);
 
-    const target = new Target();
-    target.value = 5;
-    const detach = store.attach(target);
+    const targetInstance = new Target();
+    targetInstance.value = 5;
+    const detach = store.attach(targetInstance);
 
     expect(events).toEqual(['setup', 'subscribe', 'attach']);
     expect(store.state.count).toBe(5);
 
-    await store.request.increment();
+    await store.increment();
     expect(store.state.count).toBe(6);
     expect(events).toContain('increment');
 
@@ -54,74 +56,45 @@ describe('store lifecycle integration', () => {
     store.destroy();
     expect(store.destroyed).toBe(true);
   });
-
-  it('request with guards', async () => {
-    let ready = false;
-    const isReady = () => ready;
-
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        guardedAction: {
-          guard: [isReady],
-          handler: (_, _ctx) => 'completed',
-        },
-      },
-    });
-
-    const store = createStore({
-      features: [feature],
-      onError: () => {},
-    });
-
-    store.attach({});
-
-    // Test 1: Guard rejects when not ready
-    const failPromise = store.request.guardedAction().catch((e) => e);
-    await expect(failPromise).resolves.toMatchObject({ code: 'REJECTED' });
-
-    // Test 2: Guard passes when ready
-    ready = true;
-    const successPromise = store.request.guardedAction();
-    await expect(successPromise).resolves.toBe('completed');
-  });
 });
 
-describe('request coordination', () => {
-  it('cancel option aborts related requests', async () => {
+describe('task coordination', () => {
+  it('cancels option aborts related tasks', async () => {
     const events: string[] = [];
 
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        load: {
-          key: 'load',
-          async handler(_, { signal }) {
-            events.push('load-start');
-            await new Promise((resolve, reject) => {
-              const timeout = setTimeout(() => {
-                events.push('load-complete');
-                resolve('loaded');
-              }, 100);
-              signal.addEventListener('abort', () => {
-                clearTimeout(timeout);
-                events.push('load-aborted');
-                reject(new Error('aborted'));
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        loading: false,
+        load() {
+          return task({
+            key: 'load',
+            async handler({ signal }) {
+              events.push('load-start');
+              await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                  events.push('load-complete');
+                  resolve('loaded');
+                }, 100);
+                signal.addEventListener('abort', () => {
+                  clearTimeout(timeout);
+                  events.push('load-aborted');
+                  reject(new Error('aborted'));
+                });
               });
-            });
-          },
+            },
+          });
         },
-        stop: {
-          cancel: ['load'],
-          handler: (_, _ctx) => {
-            events.push('stop');
-          },
+        stop() {
+          return task({
+            cancels: ['load'],
+            handler() {
+              events.push('stop');
+            },
+          });
         },
-      },
+      }),
+      getSnapshot: () => ({ loading: false }),
+      subscribe: () => {},
     });
 
     const store = createStore({
@@ -131,10 +104,10 @@ describe('request coordination', () => {
 
     store.attach({});
 
-    const loadPromise = store.request.load();
+    const loadPromise = store.load();
     await new Promise((r) => setTimeout(r, 10));
 
-    await store.request.stop();
+    await store.stop();
 
     await loadPromise.catch(() => {});
 
@@ -144,68 +117,64 @@ describe('request coordination', () => {
     expect(events).not.toContain('load-complete');
   });
 
-  it('dynamic keys enable parallel execution', async () => {
+  it('different keys enable parallel execution', async () => {
     const completionOrder: number[] = [];
 
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        fetchTrack: {
-          key: (id: number) => `track-${id}`,
-          async handler(id: number, _ctx) {
-            await new Promise((r) => setTimeout(r, 10 * id));
-            completionOrder.push(id);
-            return id;
-          },
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        fetching: false,
+        fetchTrack(id: number) {
+          return task({
+            key: `track-${id}`,
+            async handler() {
+              await new Promise((r) => setTimeout(r, 10 * id));
+              completionOrder.push(id);
+              return id;
+            },
+          });
         },
-      },
-    });
-
-    const store = createStore({
-      features: [feature],
+      }),
+      getSnapshot: () => ({ fetching: false }),
+      subscribe: () => {},
     });
 
+    const store = createStore({ features: [feature] });
     store.attach({});
 
-    // All should run in parallel with different keys
-    const [r3, r1, r2] = await Promise.all([
-      store.request.fetchTrack(3),
-      store.request.fetchTrack(1),
-      store.request.fetchTrack(2),
-    ]);
+    const [r3, r1, r2] = await Promise.all([store.fetchTrack(3), store.fetchTrack(1), store.fetchTrack(2)]);
 
     expect(r1).toBe(1);
     expect(r2).toBe(2);
     expect(r3).toBe(3);
-    expect(completionOrder).toEqual([1, 2, 3]); // Complete in duration order
+    expect(completionOrder).toEqual([1, 2, 3]);
   });
 
-  it('same key requests supersede each other', async () => {
+  it('same key tasks supersede each other', async () => {
     const executed: string[] = [];
 
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        action: {
-          key: 'shared',
-          async handler(name: string, { signal }) {
-            executed.push(`${name}-start`);
-            await new Promise((resolve, reject) => {
-              const timeout = setTimeout(resolve, 50);
-              signal.addEventListener('abort', () => {
-                clearTimeout(timeout);
-                reject(signal.reason);
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        running: false,
+        action(name: string) {
+          return task({
+            key: 'shared',
+            async handler({ signal }) {
+              executed.push(`${name}-start`);
+              await new Promise((resolve, reject) => {
+                const timeout = setTimeout(resolve, 50);
+                signal.addEventListener('abort', () => {
+                  clearTimeout(timeout);
+                  reject(signal.reason);
+                });
               });
-            });
-            executed.push(`${name}-end`);
-            return name;
-          },
+              executed.push(`${name}-end`);
+              return name;
+            },
+          });
         },
-      },
+      }),
+      getSnapshot: () => ({ running: false }),
+      subscribe: () => {},
     });
 
     const store = createStore({
@@ -215,158 +184,75 @@ describe('request coordination', () => {
 
     store.attach({});
 
-    const p1 = store.request.action('first');
-    const p2 = store.request.action('second');
-    const p3 = store.request.action('third');
+    const p1 = store.action('first');
+    const p2 = store.action('second');
+    const p3 = store.action('third');
 
     await expect(p1).rejects.toThrow();
     await expect(p2).rejects.toThrow();
     await expect(p3).resolves.toBe('third');
 
-    // All three start immediately (immediate execution)
     expect(executed).toContain('first-start');
     expect(executed).toContain('second-start');
     expect(executed).toContain('third-start');
-    // Only third completes (others aborted via signal)
     expect(executed).toContain('third-end');
     expect(executed).not.toContain('first-end');
     expect(executed).not.toContain('second-end');
   });
 
-  it('CANCEL_ALL aborts all pending requests (nuclear reset)', async () => {
-    const events: string[] = [];
-
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        fetch: {
-          key: 'fetch',
-          async handler(_, { signal }) {
-            events.push('fetch-start');
-            await new Promise((resolve, reject) => {
-              const timeout = setTimeout(() => {
-                events.push('fetch-complete');
-                resolve('fetched');
-              }, 100);
-              signal.addEventListener('abort', () => {
-                clearTimeout(timeout);
-                events.push('fetch-aborted');
-                reject(signal.reason);
-              });
-            });
-          },
-        },
-        seek: {
-          key: 'seek',
-          async handler(_, { signal }) {
-            events.push('seek-start');
-            await new Promise((resolve, reject) => {
-              const timeout = setTimeout(() => {
-                events.push('seek-complete');
-                resolve('seeked');
-              }, 100);
-              signal.addEventListener('abort', () => {
-                clearTimeout(timeout);
-                events.push('seek-aborted');
-                reject(signal.reason);
-              });
-            });
-          },
-        },
-        load: {
-          cancel: CANCEL_ALL,
-          handler: () => {
-            events.push('load');
-          },
-        },
-      },
-    });
-
-    const store = createStore({
-      features: [feature],
-      onError: () => {},
-    });
-
-    store.attach({});
-
-    // Start multiple requests
-    const fetchPromise = store.request.fetch();
-    const seekPromise = store.request.seek();
-    await new Promise((r) => setTimeout(r, 10));
-
-    // Nuclear reset
-    await store.request.load();
-
-    await fetchPromise.catch(() => {});
-    await seekPromise.catch(() => {});
-
-    expect(events).toContain('fetch-start');
-    expect(events).toContain('seek-start');
-    expect(events).toContain('fetch-aborted');
-    expect(events).toContain('seek-aborted');
-    expect(events).toContain('load');
-    expect(events).not.toContain('fetch-complete');
-    expect(events).not.toContain('seek-complete');
-  });
-
-  it('mode: shared allows multiple requests to share fate', async () => {
+  it('mode: shared allows multiple tasks to share fate', async () => {
     let handlerCallCount = 0;
 
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        play: {
-          key: 'playback',
-          mode: 'shared',
-          async handler() {
-            handlerCallCount++;
-            await new Promise((r) => setTimeout(r, 50));
-            return 'playing';
-          },
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        playing: false,
+        play() {
+          return task({
+            key: 'playback',
+            mode: 'shared',
+            async handler() {
+              handlerCallCount++;
+              await new Promise((r) => setTimeout(r, 50));
+              return 'playing';
+            },
+          });
         },
-      },
-    });
-
-    const store = createStore({
-      features: [feature],
+      }),
+      getSnapshot: () => ({ playing: false }),
+      subscribe: () => {},
     });
 
+    const store = createStore({ features: [feature] });
     store.attach({});
 
-    // Multiple play calls while one is pending
-    const p1 = store.request.play();
-    const p2 = store.request.play();
-    const p3 = store.request.play();
+    const p1 = store.play();
+    const p2 = store.play();
+    const p3 = store.play();
 
-    // All should resolve to the same value (shared fate)
     const [r1, r2, r3] = await Promise.all([p1, p2, p3]);
     expect(r1).toBe('playing');
     expect(r2).toBe('playing');
     expect(r3).toBe('playing');
-
-    // Handler should only be called once (not superseded)
     expect(handlerCallCount).toBe(1);
   });
 
   it('mode: shared rejects all promises together on error', async () => {
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        play: {
-          key: 'playback',
-          mode: 'shared',
-          async handler() {
-            await new Promise((r) => setTimeout(r, 20));
-            throw new Error('playback failed');
-          },
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        playing: false,
+        play() {
+          return task({
+            key: 'playback',
+            mode: 'shared',
+            async handler() {
+              await new Promise((r) => setTimeout(r, 20));
+              throw new Error('playback failed');
+            },
+          });
         },
-      },
+      }),
+      getSnapshot: () => ({ playing: false }),
+      subscribe: () => {},
     });
 
     const store = createStore({
@@ -376,49 +262,45 @@ describe('request coordination', () => {
 
     store.attach({});
 
-    const p1 = store.request.play();
-    const p2 = store.request.play();
+    const p1 = store.play();
+    const p2 = store.play();
 
-    // Both should reject with the same error
     await expect(p1).rejects.toThrow('playback failed');
     await expect(p2).rejects.toThrow('playback failed');
   });
 
-  it('mode: shared allows new request after previous completes', async () => {
+  it('mode: shared allows new task after previous completes', async () => {
     let callCount = 0;
 
-    const feature = createFeature<unknown>()({
-      initialState: {},
-      getSnapshot: () => ({}),
-      subscribe: () => {},
-      request: {
-        play: {
-          key: 'playback',
-          mode: 'shared',
-          async handler() {
-            callCount++;
-            await new Promise((r) => setTimeout(r, 10));
-            return `call-${callCount}`;
-          },
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        playing: false,
+        play() {
+          return task({
+            key: 'playback',
+            mode: 'shared',
+            async handler() {
+              callCount++;
+              await new Promise((r) => setTimeout(r, 10));
+              return `call-${callCount}`;
+            },
+          });
         },
-      },
-    });
-
-    const store = createStore({
-      features: [feature],
+      }),
+      getSnapshot: () => ({ playing: false }),
+      subscribe: () => {},
     });
 
+    const store = createStore({ features: [feature] });
     store.attach({});
 
-    // First batch shares fate
-    const p1 = store.request.play();
-    const p2 = store.request.play();
+    const p1 = store.play();
+    const p2 = store.play();
     const [r1, r2] = await Promise.all([p1, p2]);
     expect(r1).toBe('call-1');
     expect(r2).toBe('call-1');
 
-    // After completion, new request starts fresh
-    const p3 = store.request.play();
+    const p3 = store.play();
     const r3 = await p3;
     expect(r3).toBe('call-2');
 
@@ -427,78 +309,17 @@ describe('request coordination', () => {
 });
 
 describe('state syncing', () => {
-  it('updates only trigger subscriptions for changed keys', async () => {
-    const volumeUpdates: number[] = [];
-    const mutedUpdates: boolean[] = [];
-
-    class Target extends EventTarget {
-      volume = 1;
-      muted = false;
-    }
-
-    const feature = createFeature<Target>()({
-      initialState: {
-        volume: 1,
-        muted: false,
-      },
-      getSnapshot: ({ target }) => ({
-        volume: target.volume,
-        muted: target.muted,
-      }),
-      subscribe: ({ target, update, signal }) => {
-        target.addEventListener('volumechange', update, { signal });
-        target.addEventListener('mutechange', update, { signal });
-      },
-      request: {
-        setVolume: (volume: number, { target }) => {
-          target.volume = volume;
-          target.dispatchEvent(new Event('volumechange'));
-        },
-        setMuted: (muted: boolean, { target }) => {
-          target.muted = muted;
-          target.dispatchEvent(new Event('mutechange'));
-        },
-      },
-    });
-
-    const store = createStore({
-      features: [feature],
-    });
-
-    store.attach(new Target());
-
-    store.subscribe(['volume'], () => {
-      volumeUpdates.push(store.state.volume);
-    });
-
-    store.subscribe(['muted'], () => {
-      mutedUpdates.push(store.state.muted);
-    });
-
-    await store.request.setVolume(0.5);
-    flush();
-    await store.request.setMuted(true);
-    flush();
-    await store.request.setVolume(0.8);
-    flush();
-
-    expect(volumeUpdates).toEqual([0.5, 0.8]);
-    expect(mutedUpdates).toEqual([true]);
-  });
-
   it('multiple features merge state correctly', () => {
-    const audioFeature = createFeature<{ volume: number; rate: number }>()({
-      initialState: { volume: 1 },
+    const audioFeature = defineFeature<{ volume: number; rate: number }>()({
+      state: () => ({ volume: 1 }),
       getSnapshot: ({ target }) => ({ volume: target.volume }),
       subscribe: () => {},
-      request: {},
     });
 
-    const playbackFeature = createFeature<{ volume: number; rate: number }>()({
-      initialState: { rate: 1 },
+    const playbackFeature = defineFeature<{ volume: number; rate: number }>()({
+      state: () => ({ rate: 1 }),
       getSnapshot: ({ target }) => ({ rate: target.rate }),
       subscribe: () => {},
-      request: {},
     });
 
     const store = createStore({
@@ -508,7 +329,7 @@ describe('state syncing', () => {
     const target = { volume: 0.5, rate: 1.5 };
     store.attach(target);
 
-    expect(store.state).toEqual({
+    expect(store.state).toMatchObject({
       volume: 0.5,
       rate: 1.5,
     });
@@ -516,29 +337,28 @@ describe('state syncing', () => {
 });
 
 describe('immediate execution', () => {
-  it('request handler side effect triggers event and state sync', async () => {
-    // Mock media that dispatches 'play' event when play() is called
+  it('task handler side effect triggers event and state sync', async () => {
     class MockMedia extends EventTarget {
       paused = true;
-
       play() {
         this.paused = false;
         this.dispatchEvent(new Event('play'));
       }
     }
 
-    const playbackFeature = createFeature<MockMedia>()({
-      initialState: { paused: true },
+    const playbackFeature = defineFeature<MockMedia>()({
+      state: ({ task }) => ({
+        paused: true,
+        play() {
+          return task(({ target }) => {
+            target.play();
+          });
+        },
+      }),
       getSnapshot: ({ target }) => ({ paused: target.paused }),
       subscribe: ({ target, update, signal }) => {
-        // State syncs when 'play' event fires
         target.addEventListener('play', update, { signal });
       },
-      request: {
-        play: (_, { target }) => {
-          target.play(); // Triggers event → update → getSnapshot
-        },
-      },
     });
 
     const store = createStore({ features: [playbackFeature] });
@@ -547,10 +367,150 @@ describe('immediate execution', () => {
 
     expect(store.state.paused).toBe(true);
 
-    store.request.play();
+    store.play();
 
-    // Validates: handler ran → play() called → event fired → state synced
     expect(target.paused).toBe(false);
     expect(store.state.paused).toBe(false);
   });
 });
+
+describe('meta tracing', () => {
+  it('store.meta() passes meta to task handlers', async () => {
+    let receivedMeta: unknown = null;
+
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        playing: false,
+        play() {
+          return task({
+            key: 'playback',
+            handler({ meta }) {
+              receivedMeta = meta;
+            },
+          });
+        },
+      }),
+      getSnapshot: () => ({ playing: false }),
+      subscribe: () => {},
+    });
+
+    const store = createStore({ features: [feature] });
+    store.attach({});
+
+    await store.meta({ source: 'user', reason: 'button-click' }).play();
+
+    expect(receivedMeta).toMatchObject({
+      source: 'user',
+      reason: 'button-click',
+    });
+  });
+
+  it('onTaskStart and onTaskEnd callbacks fire', async () => {
+    const events: string[] = [];
+
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        count: 0,
+        increment() {
+          return task({
+            key: 'increment',
+            async handler() {
+              await new Promise((r) => setTimeout(r, 10));
+            },
+          });
+        },
+      }),
+      getSnapshot: () => ({ count: 0 }),
+      subscribe: () => {},
+    });
+
+    const store = createStore({
+      features: [feature],
+      onTaskStart: ({ key }) => events.push(`start:${String(key)}`),
+      onTaskEnd: ({ key, error }) => events.push(`end:${String(key)}${error ? ':error' : ''}`),
+    });
+
+    store.attach({});
+
+    await store.increment();
+
+    expect(events).toEqual(['start:increment', 'end:increment']);
+  });
+
+  it('pending tracks running tasks', async () => {
+    const feature = defineFeature<unknown>()({
+      state: ({ task }) => ({
+        loading: false,
+        load() {
+          return task({
+            key: 'load',
+            async handler() {
+              await new Promise((r) => setTimeout(r, 50));
+            },
+          });
+        },
+      }),
+      getSnapshot: () => ({ loading: false }),
+      subscribe: () => {},
+    });
+
+    const store = createStore({ features: [feature] });
+    store.attach({});
+
+    expect(store.pending.load).toBeUndefined();
+
+    const promise = store.load();
+
+    expect(store.pending.load).toBeDefined();
+    expect(store.pending.load?.key).toBe('load');
+    expect(store.pending.load?.startedAt).toBeTypeOf('number');
+
+    await promise;
+
+    expect(store.pending.load).toBeUndefined();
+  });
+});
+
+describe('sync actions', () => {
+  it('target() allows sync mutations without task', () => {
+    class Target {
+      volume = 1;
+    }
+
+    const feature = defineFeature<Target>()({
+      state: ({ target }) => ({
+        volume: 1,
+        setVolume(value: number) {
+          target().volume = value;
+        },
+      }),
+      getSnapshot: ({ target: t }) => ({ volume: t.volume }),
+      subscribe: () => {},
+    });
+
+    const store = createStore({ features: [feature] });
+    const targetInstance = new Target();
+
+    store.attach(targetInstance);
+    store.setVolume(0.5);
+
+    expect(targetInstance.volume).toBe(0.5);
+  });
+
+  it('target() throws when not attached', () => {
+    const feature = defineFeature<unknown>()({
+      state: ({ target }) => ({
+        value: 0,
+        doSomething() {
+          target();
+        },
+      }),
+      getSnapshot: () => ({ value: 0 }),
+      subscribe: () => {},
+    });
+
+    const store = createStore({ features: [feature] });
+
+    expect(() => store.doSomething()).toThrow('NO_TARGET');
+  });
+});
diff --git a/packages/store/src/core/tests/request.test.ts b/packages/store/src/core/tests/request.test.ts
index 2f335c8a..2949b5a0 100644
--- a/packages/store/src/core/tests/request.test.ts
+++ b/packages/store/src/core/tests/request.test.ts
@@ -1,13 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
-import {
-  createRequestMeta,
-  createRequestMetaFromEvent,
-  isRequestMeta,
-  REQUEST_META,
-  resolveRequestCancel,
-  resolveRequestKey,
-} from '../request';
+import { createRequestMeta, createRequestMetaFromEvent, isRequestMeta, REQUEST_META } from '../request';
 
 describe('request', () => {
   describe('meta', () => {
@@ -111,39 +104,4 @@ describe('request', () => {
       });
     });
   });
-
-  describe('resolveRequestKey', () => {
-    it('returns string key directly', () => {
-      expect(resolveRequestKey('my-key', undefined)).toBe('my-key');
-    });
-
-    it('calls function with input', () => {
-      const keyFn = (id: string) => `track-${id}`;
-      expect(resolveRequestKey(keyFn, 'abc')).toBe('track-abc');
-    });
-
-    it('handles symbol keys', () => {
-      const sym = Symbol('@videojs/unique');
-      expect(resolveRequestKey(sym, undefined)).toBe(sym);
-    });
-  });
-
-  describe('resolveRequestCancelNames', () => {
-    it('returns empty array for undefined', () => {
-      expect(resolveRequestCancel(undefined, null)).toEqual([]);
-    });
-
-    it('wraps single name in array', () => {
-      expect(resolveRequestCancel('seek', null)).toEqual(['seek']);
-    });
-
-    it('returns array directly', () => {
-      expect(resolveRequestCancel(['seek', 'load'], null)).toEqual(['seek', 'load']);
-    });
-
-    it('calls function with input', () => {
-      const cancelFn = (type: string) => [`${type}Loading`, `${type}Fetch`];
-      expect(resolveRequestCancel(cancelFn, 'video')).toEqual(['videoLoading', 'videoFetch']);
-    });
-  });
 });
diff --git a/packages/store/src/core/tests/state.test.ts b/packages/store/src/core/tests/state.test.ts
index 19911bf5..7d13b3d3 100644
--- a/packages/store/src/core/tests/state.test.ts
+++ b/packages/store/src/core/tests/state.test.ts
@@ -129,62 +129,6 @@ describe('createState', () => {
     });
   });
 
-  describe('subscribe with keys', () => {
-    it('only notifies for specified keys', () => {
-      const state = createTestState();
-      const volumeListener = vi.fn();
-      const mutedListener = vi.fn();
-
-      state.subscribe(['volume'], volumeListener);
-      state.subscribe(['muted'], mutedListener);
-
-      state.set('volume', 0.5);
-      flush();
-
-      expect(volumeListener).toHaveBeenCalledOnce();
-      expect(mutedListener).not.toHaveBeenCalled();
-
-      state.set('muted', true);
-      flush();
-
-      expect(volumeListener).toHaveBeenCalledOnce();
-      expect(mutedListener).toHaveBeenCalledOnce();
-    });
-
-    it('notifies for multiple specified keys', () => {
-      const state = createTestState();
-      const listener = vi.fn();
-
-      state.subscribe(['volume', 'muted'], listener);
-
-      state.set('volume', 0.5);
-      flush();
-      expect(listener).toHaveBeenCalledOnce();
-
-      state.set('muted', true);
-      flush();
-      expect(listener).toHaveBeenCalledTimes(2);
-
-      state.set('currentTime', 10);
-      flush();
-      expect(listener).toHaveBeenCalledTimes(2); // not notified
-    });
-
-    it('unsubscribes from all keys', () => {
-      const state = createTestState();
-      const listener = vi.fn();
-
-      const unsub = state.subscribe(['volume', 'muted'], listener);
-      unsub();
-
-      state.set('volume', 0.5);
-      state.set('muted', true);
-      flush();
-
-      expect(listener).not.toHaveBeenCalled();
-    });
-  });
-
   describe('isState', () => {
     it('returns true for state created by createState', () => {
       const state = createTestState();
diff --git a/packages/store/src/core/tests/store.test.ts b/packages/store/src/core/tests/store.test.ts
index e21dad8d..a5e27392 100644
--- a/packages/store/src/core/tests/store.test.ts
+++ b/packages/store/src/core/tests/store.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 
-import { createFeature } from '../feature';
+import { defineFeature } from '../feature';
 import { flush } from '../state';
 import { createStore } from '../store';
 
@@ -14,8 +14,23 @@ describe('store', () => {
     pause = vi.fn();
   }
 
-  const audioFeature = createFeature<MockMedia>()({
-    initialState: { volume: 1, muted: false },
+  const audioFeature = defineFeature<MockMedia>()({
+    state: ({ task }) => ({
+      volume: 1,
+      muted: false,
+      setVolume(volume: number) {
+        return task(({ target }) => {
+          target.volume = volume;
+          target.dispatchEvent(new Event('volumechange'));
+        });
+      },
+      setMuted(muted: boolean) {
+        return task(({ target }) => {
+          target.muted = muted;
+          target.dispatchEvent(new Event('volumechange'));
+        });
+      },
+    }),
     getSnapshot: ({ target }) => ({
       volume: target.volume,
       muted: target.muted,
@@ -26,38 +41,32 @@ describe('store', () => {
         target.removeEventListener('volumechange', update);
       });
     },
-    request: {
-      setVolume: (volume: number, { target }) => {
-        target.volume = volume;
-        target.dispatchEvent(new Event('volumechange'));
-      },
-      setMuted: (muted: boolean, { target }) => {
-        target.muted = muted;
-        target.dispatchEvent(new Event('volumechange'));
-      },
-    },
   });
 
-  const playbackFeature = createFeature<MockMedia>()({
-    initialState: { paused: true },
+  const playbackFeature = defineFeature<MockMedia>()({
+    state: ({ task }) => ({
+      paused: true,
+      play() {
+        return task({
+          key: 'playback',
+          async handler({ target }) {
+            target.play();
+            target.paused = false;
+          },
+        });
+      },
+      pause() {
+        return task({
+          key: 'playback',
+          async handler({ target }) {
+            target.pause();
+            target.paused = true;
+          },
+        });
+      },
+    }),
     getSnapshot: ({ target }) => ({ paused: target.paused }),
     subscribe: () => {},
-    request: {
-      play: {
-        key: 'playback',
-        async handler(_, { target }) {
-          target.play();
-          target.paused = false;
-        },
-      },
-      pause: {
-        key: 'playback',
-        async handler(_, { target }) {
-          target.pause();
-          target.paused = true;
-        },
-      },
-    },
   });
 
   describe('creation', () => {
@@ -66,7 +75,7 @@ describe('store', () => {
         features: [audioFeature, playbackFeature],
       });
 
-      expect(store.state).toEqual({
+      expect(store.state).toMatchObject({
         volume: 1,
         muted: false,
         paused: true,
@@ -99,7 +108,7 @@ describe('store', () => {
 
       store.attach(media);
 
-      expect(store.state).toEqual({ volume: 0.5, muted: true });
+      expect(store.state).toMatchObject({ volume: 0.5, muted: true });
       expect(store.target).toBe(media);
     });
 
@@ -169,8 +178,8 @@ describe('store', () => {
     });
   });
 
-  describe('request', () => {
-    it('executes request on target', async () => {
+  describe('actions', () => {
+    it('executes action on target', async () => {
       const store = createStore({
         features: [audioFeature],
       });
@@ -178,7 +187,7 @@ describe('store', () => {
       const media = new MockMedia();
       store.attach(media);
 
-      await store.request.setVolume(0.5);
+      await store.setVolume(0.5);
 
       expect(media.volume).toBe(0.5);
     });
@@ -186,23 +195,23 @@ describe('store', () => {
     it('throws StoreError without target', async () => {
       const store = createStore({
         features: [audioFeature],
-        onError: () => {}, // silence errors
+        onError: () => {},
       });
 
-      await expect(store.request.setVolume(0.5)).rejects.toMatchObject({ code: 'NO_TARGET' });
+      await expect(store.setVolume(0.5)).rejects.toMatchObject({ code: 'NO_TARGET' });
     });
 
-    it('coordinates requests with same key', async () => {
+    it('coordinates actions with same key', async () => {
       const store = createStore({
         features: [playbackFeature],
-        onError: () => {}, // silence errors
+        onError: () => {},
       });
 
       const media = new MockMedia();
       store.attach(media);
 
-      const playPromise = store.request.play();
-      const pausePromise = store.request.pause();
+      const playPromise = store.play();
+      const pausePromise = store.pause();
 
       await expect(playPromise).rejects.toMatchObject({ code: 'SUPERSEDED' });
       await pausePromise;
@@ -210,20 +219,23 @@ describe('store', () => {
       expect(media.paused).toBe(true);
     });
 
-    it('accepts metadata', async () => {
-      const handlerSpy = vi.fn();
+    it('passes meta to handler', async () => {
+      let receivedMeta: unknown = null;
 
-      const feature = createFeature<MockMedia>()({
-        initialState: {},
-        getSnapshot: () => ({}),
-        subscribe: () => {},
-        request: {
-          action: {
-            handler: (_, ctx) => {
-              handlerSpy(ctx.meta);
-            },
+      const feature = defineFeature<MockMedia>()({
+        state: ({ task }) => ({
+          value: 0,
+          action() {
+            return task({
+              key: 'action',
+              handler({ meta }) {
+                receivedMeta = meta;
+              },
+            });
           },
-        },
+        }),
+        getSnapshot: () => ({ value: 0 }),
+        subscribe: () => {},
       });
 
       const store = createStore({
@@ -232,17 +244,86 @@ describe('store', () => {
 
       store.attach(new MockMedia());
 
-      await store.request.action(undefined, {
+      await store.meta({ source: 'user', reason: 'test' }).action();
+
+      expect(receivedMeta).toMatchObject({
         source: 'user',
         reason: 'test',
       });
+    });
 
-      expect(handlerSpy).toHaveBeenCalledWith(
-        expect.objectContaining({
-          source: 'user',
-          reason: 'test',
-        })
-      );
+    it('clears meta after action without task()', async () => {
+      let receivedMeta: unknown = 'not-called';
+
+      const feature = defineFeature<MockMedia>()({
+        state: ({ task }) => ({
+          value: 0,
+          // Sync action that doesn't use task()
+          syncAction() {
+            // Does nothing with meta
+          },
+          // Action that uses task() to capture meta
+          asyncAction() {
+            return task({
+              key: 'async',
+              handler({ meta }) {
+                receivedMeta = meta;
+              },
+            });
+          },
+        }),
+        getSnapshot: () => ({ value: 0 }),
+        subscribe: () => {},
+      });
+
+      const store = createStore({
+        features: [feature],
+      });
+
+      store.attach(new MockMedia());
+
+      // Call sync action with meta - meta should be cleared after
+      store.meta({ source: 'user', reason: 'sync' }).syncAction();
+
+      // Call async action without meta - should NOT receive leaked meta
+      await store.asyncAction();
+
+      expect(receivedMeta).toBeNull();
+    });
+
+    it('isolates meta between chained calls', async () => {
+      const receivedMetas: unknown[] = [];
+
+      const feature = defineFeature<MockMedia>()({
+        state: ({ task }) => ({
+          value: 0,
+          action() {
+            return task({
+              key: 'action',
+              handler({ meta }) {
+                receivedMetas.push(meta);
+              },
+            });
+          },
+        }),
+        getSnapshot: () => ({ value: 0 }),
+        subscribe: () => {},
+      });
+
+      const store = createStore({
+        features: [feature],
+      });
+
+      store.attach(new MockMedia());
+
+      await store.meta({ source: 'first' }).action();
+      await store.meta({ source: 'second' }).action();
+      await store.action(); // No meta
+
+      expect(receivedMetas).toHaveLength(3);
+      expect(receivedMetas[0]).toMatchObject({ source: 'first' });
+      expect(receivedMetas[1]).toMatchObject({ source: 'second' });
+      expect(receivedMetas[2]).toBeNull();
     });
   });
 
@@ -258,7 +339,7 @@ describe('store', () => {
       const listener = vi.fn();
       store.subscribe(listener);
 
-      await store.request.setVolume(0.5);
+      await store.setVolume(0.5);
       flush();
 
       expect(listener).toHaveBeenCalled();
@@ -277,7 +358,7 @@ describe('store', () => {
       const unsubscribe = store.subscribe(listener);
       unsubscribe();
 
-      await store.request.setVolume(0.5);
+      await store.setVolume(0.5);
       flush();
 
       expect(listener).not.toHaveBeenCalled();
@@ -298,7 +379,7 @@ describe('store', () => {
       expect(store.target).toBeNull();
     });
 
-    it('rejects requests after destroy', async () => {
+    it('rejects actions after destroy', async () => {
       const store = createStore({
         features: [audioFeature],
       });
@@ -306,23 +387,25 @@ describe('store', () => {
       store.attach(new MockMedia());
       store.destroy();
 
-      await expect(store.request.setVolume(0.5)).rejects.toThrow();
+      await expect(store.setVolume(0.5)).rejects.toThrow();
     });
   });
 
   describe('error handling', () => {
-    it('calls onError for request errors', async () => {
+    it('calls onError for action errors', async () => {
       const onError = vi.fn();
 
-      const failingFeature = createFeature<MockMedia>()({
-        initialState: {},
-        getSnapshot: () => ({}),
-        subscribe: () => {},
-        request: {
-          fail: () => {
-            throw new Error('request failed');
+      const failingFeature = defineFeature<MockMedia>()({
+        state: ({ task }) => ({
+          value: 0,
+          fail() {
+            return task(() => {
+              throw new Error('action failed');
+            });
           },
-        },
+        }),
+        getSnapshot: () => ({ value: 0 }),
+        subscribe: () => {},
       });
 
       const store = createStore({
@@ -332,7 +415,7 @@ describe('store', () => {
 
       store.attach(new MockMedia());
 
-      await store.request.fail().catch(() => {});
+      await store.fail().catch(() => {});
 
       expect(onError).toHaveBeenCalledWith(
         expect.objectContaining({
diff --git a/packages/store/src/core/tests/store.types.test.ts b/packages/store/src/core/tests/store.types.test.ts
deleted file mode 100644
index cbe664d2..00000000
--- a/packages/store/src/core/tests/store.types.test.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import { createFeature } from '../feature';
-import type { InferStoreRequests, InferStoreState, InferStoreTarget } from '../store';
-import { createStore } from '../store';
-
-interface MockTarget {
-  volume: number;
-  muted: boolean;
-}
-
-const audioFeature = createFeature<MockTarget>()({
-  initialState: { volume: 1, muted: false },
-  getSnapshot: ({ target }) => ({ volume: target.volume, muted: target.muted }),
-  subscribe: () => {},
-  request: {
-    setVolume: (volume: number, { target }) => {
-      target.volume = volume;
-      return volume;
-    },
-    setMuted: (muted: boolean, { target }) => {
-      target.muted = muted;
-      return muted;
-    },
-  },
-});
-
-const playbackFeature = createFeature<MockTarget>()({
-  initialState: { playing: false },
-  getSnapshot: () => ({ playing: false }),
-  subscribe: () => {},
-  request: {
-    play: () => true,
-    pause: () => false,
-  },
-});
-
-function createTestStore() {
-  return createStore({ features: [audioFeature, playbackFeature] });
-}
-
-function createSingleFeatureStore() {
-  return createStore({ features: [audioFeature] });
-}
-
-describe('store types', () => {
-  describe('createStore', () => {
-    it('state has union of all feature states', () => {
-      const store = createTestStore();
-
-      expectTypeOf(store.state.volume).toEqualTypeOf<number>();
-      expectTypeOf(store.state.muted).toEqualTypeOf<boolean>();
-      expectTypeOf(store.state.playing).toEqualTypeOf<boolean>();
-    });
-
-    it('request has union of all feature requests', () => {
-      const store = createTestStore();
-
-      expectTypeOf(store.request).toHaveProperty('setVolume');
-      expectTypeOf(store.request).toHaveProperty('setMuted');
-      expectTypeOf(store.request).toHaveProperty('play');
-      expectTypeOf(store.request).toHaveProperty('pause');
-    });
-
-    it('request methods have correct signatures', () => {
-      const store = createSingleFeatureStore();
-
-      expectTypeOf(store.request.setVolume).toBeFunction();
-      expectTypeOf(store.request.setVolume).parameter(0).toEqualTypeOf<number>();
-      expectTypeOf(store.request.setVolume).returns.toEqualTypeOf<Promise<number>>();
-
-      expectTypeOf(store.request.setMuted).toBeFunction();
-      expectTypeOf(store.request.setMuted).parameter(0).toEqualTypeOf<boolean>();
-      expectTypeOf(store.request.setMuted).returns.toEqualTypeOf<Promise<boolean>>();
-    });
-
-    it('target is nullable before attach', () => {
-      const store = createSingleFeatureStore();
-
-      expectTypeOf(store.target).toEqualTypeOf<MockTarget | null>();
-    });
-  });
-
-  describe('InferStoreTarget', () => {
-    it('extracts target type from store', () => {
-      const _store = createSingleFeatureStore();
-      type Target = InferStoreTarget<typeof _store>;
-      const _target: Target = {} as Target;
-
-      expectTypeOf(_target).toEqualTypeOf<MockTarget>();
-    });
-  });
-
-  describe('InferStoreState', () => {
-    it('extracts state type from store', () => {
-      const _store = createTestStore();
-      type State = InferStoreState<typeof _store>;
-      const _state: State = {} as State;
-
-      expectTypeOf(_state.volume).toEqualTypeOf<number>();
-      expectTypeOf(_state.muted).toEqualTypeOf<boolean>();
-      expectTypeOf(_state.playing).toEqualTypeOf<boolean>();
-    });
-  });
-
-  describe('InferStoreRequests', () => {
-    it('extracts request types from store', () => {
-      const _store = createSingleFeatureStore();
-      type Requests = InferStoreRequests<typeof _store>;
-
-      expectTypeOf<Requests>().toHaveProperty('setVolume');
-      expectTypeOf<Requests>().toHaveProperty('setMuted');
-    });
-  });
-
-  describe('subscribe', () => {
-    it('state returns readonly snapshot', () => {
-      const store = createSingleFeatureStore();
-
-      expectTypeOf(store.state).toBeObject();
-      expectTypeOf(store.subscribe).toBeFunction();
-    });
-
-    it('state properties have correct types', () => {
-      const store = createSingleFeatureStore();
-
-      expectTypeOf(store.state.volume).toEqualTypeOf<number>();
-      expectTypeOf(store.state.muted).toEqualTypeOf<boolean>();
-    });
-  });
-});
diff --git a/packages/store/src/lit/controllers/index.ts b/packages/store/src/lit/controllers/index.ts
index 419f7b13..a9765f2a 100644
--- a/packages/store/src/lit/controllers/index.ts
+++ b/packages/store/src/lit/controllers/index.ts
@@ -1,9 +1,3 @@
-export type { AsyncStatus } from '../../shared/types';
-
-export {
-  SnapshotController,
-  type SnapshotControllerHost,
-} from './snapshot-controller';
 export {
   StoreController,
   type StoreControllerHost,
diff --git a/packages/store/src/lit/controllers/snapshot-controller.ts b/packages/store/src/lit/controllers/snapshot-controller.ts
deleted file mode 100644
index 1663107e..00000000
--- a/packages/store/src/lit/controllers/snapshot-controller.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from '@lit/reactive-element';
-import { noop } from '@videojs/utils/function';
-import type { State } from '../../core/state';
-
-export type SnapshotControllerHost = ReactiveControllerHost & HTMLElement;
-
-export interface SnapshotControllerOptions<T extends object> {
-  /** Called when state changes (after requestUpdate). */
-  onChange?: (snapshot: T) => void;
-}
-
-/**
- * Subscribes to state and triggers host updates when state changes.
- *
- * @example Basic usage
- * ```ts
- * class MyElement extends LitElement {
- *   #state = new SnapshotController(this, store.state);
- *
- *   render() {
- *     const { volume, muted } = this.#state.value;
- *     return html`<span>${muted ? 'Muted' : volume}</span>`;
- *   }
- * }
- * ```
- *
- * @example With onChange callback
- * ```ts
- * class MyElement extends LitElement {
- *   #state = new SnapshotController(this, store.state, {
- *     onChange: (state) => console.log('State changed:', state.volume),
- *   });
- * }
- * ```
- */
-export class SnapshotController<T extends object> implements ReactiveController {
-  readonly #host: SnapshotControllerHost;
-  readonly #state: State<T>;
-  readonly #onChange: ((snapshot: T) => void) | undefined;
-
-  #unsubscribe = noop;
-
-  constructor(host: SnapshotControllerHost, state: State<T>, options?: SnapshotControllerOptions<T>) {
-    this.#host = host;
-    this.#state = state;
-    this.#onChange = options?.onChange;
-    host.addController(this);
-  }
-
-  get value(): T {
-    return this.#state.current;
-  }
-
-  hostConnected(): void {
-    this.#unsubscribe = this.#state.subscribe(() => {
-      this.#host.requestUpdate();
-      this.#onChange?.(this.#state.current);
-    });
-  }
-
-  hostDisconnected(): void {
-    this.#unsubscribe();
-    this.#unsubscribe = noop;
-  }
-}
-
-export namespace SnapshotController {
-  export type Host = SnapshotControllerHost;
-  export type Options<T extends object> = SnapshotControllerOptions<T>;
-}
diff --git a/packages/store/src/lit/controllers/store-controller.ts b/packages/store/src/lit/controllers/store-controller.ts
index 5c93604a..9308a9cd 100644
--- a/packages/store/src/lit/controllers/store-controller.ts
+++ b/packages/store/src/lit/controllers/store-controller.ts
@@ -1,11 +1,11 @@
-import type { AnyStore, InferStoreRequests, InferStoreState } from '../../core/store';
+import type { AnyStore, InferStoreState } from '../../core/store';
 import type { StoreSource } from '../store-accessor';
 import type { SubscriptionControllerHost } from './subscription-controller';
 import { SubscriptionController } from './subscription-controller';
 
 export type StoreControllerHost = SubscriptionControllerHost;
 
-export type StoreControllerValue<Store extends AnyStore> = InferStoreState<Store> & InferStoreRequests<Store>;
+export type StoreControllerValue<Store extends AnyStore> = InferStoreState<Store>;
 
 /**
  * Subscribes to store state changes.
@@ -44,7 +44,7 @@ export class StoreController<Store extends AnyStore> {
   constructor(host: StoreControllerHost, source: StoreSource<Store>) {
     this.#sub = new SubscriptionController(host, source, {
       subscribe: (store, onChange) => store.subscribe(onChange),
-      getValue: (store) => ({ ...store.state, ...store.request }) as StoreControllerValue<Store>,
+      getValue: (store) => store as unknown as StoreControllerValue<Store>,
     });
   }
 
diff --git a/packages/store/src/lit/controllers/subscription-controller.ts b/packages/store/src/lit/controllers/subscription-controller.ts
index 8caccd69..3ba7f348 100644
--- a/packages/store/src/lit/controllers/subscription-controller.ts
+++ b/packages/store/src/lit/controllers/subscription-controller.ts
@@ -55,7 +55,7 @@ export class SubscriptionController<Store extends AnyStore, Value> implements Re
     this.#config = config;
 
     if (isStore(source)) {
-      this.#directStore = source;
+      this.#directStore = source as Store;
       this.#consumer = null;
     } else {
       this.#directStore = null;
diff --git a/packages/store/src/lit/controllers/tests/store-controller.test.ts b/packages/store/src/lit/controllers/tests/store-controller.test.ts
index 5fb84085..71931ab3 100644
--- a/packages/store/src/lit/controllers/tests/store-controller.test.ts
+++ b/packages/store/src/lit/controllers/tests/store-controller.test.ts
@@ -3,20 +3,29 @@ import { afterEach, describe, expect, it } from 'vitest';
 import { createCoreTestStore, createTestHost } from '../../tests/test-utils';
 import { StoreController } from '../store-controller';
 
+interface AudioState {
+  volume: number;
+  muted: boolean;
+  setVolume: (volume: number) => Promise<number>;
+  setMuted: (muted: boolean) => Promise<boolean>;
+  slowSetVolume: (volume: number) => Promise<number>;
+}
+
 describe('StoreController', () => {
   afterEach(() => {
     document.body.innerHTML = '';
   });
 
-  it('returns state and request functions spread together', () => {
+  it('returns state and action functions spread together', () => {
     const { store } = createCoreTestStore();
     const host = createTestHost();
 
     const controller = new StoreController(host, store);
+    const value = controller.value as AudioState;
 
-    expect(controller.value.volume).toBe(1);
-    expect(controller.value.muted).toBe(false);
-    expect(typeof controller.value.setVolume).toBe('function');
+    expect(value.volume).toBe(1);
+    expect(value.muted).toBe(false);
+    expect(typeof value.setVolume).toBe('function');
   });
 
   it('updates when state changes', async () => {
@@ -26,11 +35,11 @@ describe('StoreController', () => {
     const controller = new StoreController(host, store);
     document.body.appendChild(host);
 
-    expect(controller.value.volume).toBe(1);
+    expect((controller.value as AudioState).volume).toBe(1);
 
-    await store.request.setVolume!(0.5);
+    await store.setVolume(0.5);
 
-    expect(controller.value.volume).toBe(0.5);
+    expect((controller.value as AudioState).volume).toBe(0.5);
     expect(host.updateCount).toBeGreaterThan(0);
   });
 
@@ -43,7 +52,7 @@ describe('StoreController', () => {
     host.remove();
 
     const updateCountBefore = host.updateCount;
-    await store.request.setVolume!(0.5);
+    await store.setVolume(0.5);
 
     expect(host.updateCount).toBe(updateCountBefore);
   });
@@ -55,16 +64,16 @@ describe('StoreController', () => {
     const controller = new StoreController(host, store);
     document.body.appendChild(host);
 
-    await store.request.setVolume!(0.5);
-    expect(controller.value.volume).toBe(0.5);
+    await store.setVolume(0.5);
+    expect((controller.value as AudioState).volume).toBe(0.5);
 
     host.remove();
 
-    await store.request.setVolume!(0.8);
+    await store.setVolume(0.8);
 
     // Reconnect
     document.body.appendChild(host);
 
-    expect(controller.value.volume).toBe(0.8);
+    expect((controller.value as AudioState).volume).toBe(0.8);
   });
 });
diff --git a/packages/store/src/lit/controllers/tests/types.test.ts b/packages/store/src/lit/controllers/tests/types.test.ts
deleted file mode 100644
index cd1e6079..00000000
--- a/packages/store/src/lit/controllers/tests/types.test.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-
-import { createState } from '../../../core/state';
-import { createTestHost } from '../../tests/test-utils';
-import { SnapshotController } from '../snapshot-controller';
-
-describe('controller types', () => {
-  describe('SnapshotController', () => {
-    it('value has state type', () => {
-      const state = createState({ volume: 1, muted: false });
-      const host = createTestHost();
-
-      const controller = new SnapshotController(host, state);
-
-      // controller.value is the unwrapped type (without Reactive brand)
-      expectTypeOf(controller.value).toEqualTypeOf<{
-        volume: number;
-        muted: boolean;
-      }>();
-    });
-
-    it('value properties have correct types', () => {
-      const state = createState({ volume: 1, muted: false });
-      const host = createTestHost();
-
-      const controller = new SnapshotController(host, state);
-
-      expectTypeOf(controller.value.volume).toEqualTypeOf<number>();
-      expectTypeOf(controller.value.muted).toEqualTypeOf<boolean>();
-    });
-  });
-});
diff --git a/packages/store/src/lit/create-store.ts b/packages/store/src/lit/create-store.ts
index 6039f6f6..a191f52a 100644
--- a/packages/store/src/lit/create-store.ts
+++ b/packages/store/src/lit/create-store.ts
@@ -3,21 +3,20 @@ import { ContextConsumer, createContext } from '@lit/context';
 import type { ReactiveControllerHost, ReactiveElement } from '@lit/reactive-element';
 import { noop } from '@videojs/utils/function';
 import type { Constructor } from '@videojs/utils/types';
-import type { AnyFeature, UnionFeatureRequests, UnionFeatureState, UnionFeatureTarget } from '../core/feature';
-import type { StoreConfig, StoreConsumer, StoreProvider } from '../core/store';
-
-import { Store } from '../core/store';
+import type { StoreConfig } from '../core/config';
+import type { AnyFeature, UnionFeatureState } from '../core/feature';
+import type { Store } from '../core/store';
+import { createStore as createCoreStore } from '../core/store';
 import { createContainerMixin, createProviderMixin, createStoreMixin } from './mixins';
+import type { StoreConsumer, StoreProvider } from './types';
 
 export const contextKey = Symbol('@videojs/store');
 
-export interface CreateStoreConfig<Features extends AnyFeature[]>
-  extends StoreConfig<UnionFeatureTarget<Features>, Features> {}
+export interface CreateStoreConfig<Features extends AnyFeature[]> extends StoreConfig<Features> {}
 
 export type CreateStoreHost = ReactiveControllerHost & HTMLElement;
 
-export type StoreControllerValue<Features extends AnyFeature[]> = UnionFeatureState<Features> &
-  UnionFeatureRequests<Features>;
+export type StoreControllerValue<Features extends AnyFeature[]> = UnionFeatureState<Features>;
 
 export interface CreateStoreResult<Features extends AnyFeature[]> {
   /**
@@ -67,7 +66,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * }
    * ```
    */
-  context: Context<typeof contextKey, Store<UnionFeatureTarget<Features>, Features>>;
+  context: Context<typeof contextKey, Store<Features>>;
 
   /**
    * Creates a store instance for imperative access.
@@ -80,7 +79,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * store.attach(videoElement);
    * ```
    */
-  create: () => Store<UnionFeatureTarget<Features>, Features>;
+  create: () => Store<Features>;
 
   /**
    * Store controller bound to this store's context.
@@ -147,13 +146,12 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
 export function createStore<Features extends AnyFeature[]>(
   config: CreateStoreConfig<Features>
 ): CreateStoreResult<Features> {
-  type Target = UnionFeatureTarget<Features>;
-  type ProvidedStore = Store<Target, Features>;
+  type ProvidedStore = Store<Features>;
 
   const context = createContext<ProvidedStore, typeof contextKey>(contextKey);
 
   function create(): ProvidedStore {
-    return new Store(config);
+    return createCoreStore(config);
   }
 
   const ProviderMixin = createProviderMixin<Features>(context, create);
@@ -184,10 +182,8 @@ export function createStore<Features extends AnyFeature[]>(
         throw new Error('Store not available');
       }
 
-      return {
-        ...store.state,
-        ...(store.request as object),
-      } as StoreControllerValue<Features>;
+      // In v2, state and actions are directly on the store object
+      return store as unknown as StoreControllerValue<Features>;
     }
 
     hostConnected(): void {
diff --git a/packages/store/src/lit/index.ts b/packages/store/src/lit/index.ts
index 464aadd4..7871809b 100644
--- a/packages/store/src/lit/index.ts
+++ b/packages/store/src/lit/index.ts
@@ -1,9 +1,4 @@
-export type { AsyncStatus } from './controllers';
-export {
-  SnapshotController,
-  StoreController,
-  SubscriptionController,
-} from './controllers';
+export { StoreController, SubscriptionController } from './controllers';
 export type {
   CreateStoreConfig,
   CreateStoreHost,
@@ -22,3 +17,6 @@ export {
 export type { StoreSource } from './store-accessor';
 // StoreAccessor (for custom controllers)
 export { StoreAccessor, type StoreAccessorHost } from './store-accessor';
+
+// Types
+export type { StoreConsumer, StoreProvider } from './types';
diff --git a/packages/store/src/lit/mixins/container-mixin.ts b/packages/store/src/lit/mixins/container-mixin.ts
index 41504fcc..84d661cb 100644
--- a/packages/store/src/lit/mixins/container-mixin.ts
+++ b/packages/store/src/lit/mixins/container-mixin.ts
@@ -7,7 +7,8 @@ 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, StoreConsumer } from '../../core/store';
+import type { Store } from '../../core/store';
+import type { StoreConsumer } from '../types';
 
 /**
  * Creates a mixin that consumes a store from context and auto-attaches media elements.
@@ -26,9 +27,9 @@ import type { Store, StoreConsumer } from '../../core/store';
  * ```
  */
 export function createContainerMixin<Features extends AnyFeature[]>(
-  context: Context<unknown, Store<UnionFeatureTarget<Features>, Features>>
+  context: Context<unknown, Store<Features>>
 ): Mixin<ReactiveElement, StoreConsumer<Features>> {
-  type ConsumedStore = Store<UnionFeatureTarget<Features>, Features>;
+  type ConsumedStore = Store<Features>;
 
   return <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => {
     class StoreAttachElement extends BaseClass implements StoreConsumer<Features> {
diff --git a/packages/store/src/lit/mixins/index.ts b/packages/store/src/lit/mixins/index.ts
index 91319045..e82ac62a 100644
--- a/packages/store/src/lit/mixins/index.ts
+++ b/packages/store/src/lit/mixins/index.ts
@@ -1,3 +1,3 @@
-export { createStoreMixin } from './combined-mixin';
 export { createContainerMixin } from './container-mixin';
 export { createProviderMixin } from './provider-mixin';
+export { createStoreMixin } from './store-mixin';
diff --git a/packages/store/src/lit/mixins/provider-mixin.ts b/packages/store/src/lit/mixins/provider-mixin.ts
index 354cde53..ec269c45 100644
--- a/packages/store/src/lit/mixins/provider-mixin.ts
+++ b/packages/store/src/lit/mixins/provider-mixin.ts
@@ -3,8 +3,9 @@ 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, UnionFeatureTarget } from '../../core/feature';
-import type { Store, StoreProvider } from '../../core/store';
+import type { AnyFeature } from '../../core/feature';
+import type { Store } from '../../core/store';
+import type { StoreProvider } from '../types';
 
 /**
  * Creates a mixin that provides a store via context.
@@ -28,10 +29,10 @@ import type { Store, StoreProvider } from '../../core/store';
  * ```
  */
 export function createProviderMixin<Features extends AnyFeature[]>(
-  context: Context<unknown, Store<UnionFeatureTarget<Features>, Features>>,
-  factory: () => Store<UnionFeatureTarget<Features>, Features>
+  context: Context<unknown, Store<Features>>,
+  factory: () => Store<Features>
 ): <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => Base & Constructor<StoreProvider<Features>> {
-  type ProvidedStore = Store<UnionFeatureTarget<Features>, Features>;
+  type ProvidedStore = Store<Features>;
 
   return <Base extends Constructor<ReactiveElement>>(BaseClass: Base) => {
     class StoreProviderElement extends BaseClass implements StoreProvider<Features> {
diff --git a/packages/store/src/lit/mixins/combined-mixin.ts b/packages/store/src/lit/mixins/store-mixin.ts
similarity index 83%
rename from packages/store/src/lit/mixins/combined-mixin.ts
rename to packages/store/src/lit/mixins/store-mixin.ts
index b05e3324..a6090f72 100644
--- a/packages/store/src/lit/mixins/combined-mixin.ts
+++ b/packages/store/src/lit/mixins/store-mixin.ts
@@ -1,9 +1,9 @@
 import type { Context } from '@lit/context';
 import type { ReactiveElement } from '@lit/reactive-element';
 import type { Constructor, Mixin } from '@videojs/utils/types';
-import type { AnyFeature, UnionFeatureTarget } from '../../core/feature';
-
-import type { Store, StoreProvider } from '../../core/store';
+import type { AnyFeature } from '../../core/feature';
+import type { Store } from '../../core/store';
+import type { StoreProvider } from '../types';
 
 import { createContainerMixin } from './container-mixin';
 import { createProviderMixin } from './provider-mixin';
@@ -26,8 +26,8 @@ import { createProviderMixin } from './provider-mixin';
  * ```
  */
 export function createStoreMixin<Features extends AnyFeature[]>(
-  context: Context<unknown, Store<UnionFeatureTarget<Features>, Features>>,
-  factory: () => Store<UnionFeatureTarget<Features>, Features>
+  context: Context<unknown, Store<Features>>,
+  factory: () => Store<Features>
 ): Mixin<ReactiveElement, StoreProvider<Features>> {
   const ProviderMixin = createProviderMixin<Features>(context, factory);
   const ContainerMixin = createContainerMixin<Features>(context);
diff --git a/packages/store/src/lit/mixins/tests/combined-mixin.test.ts b/packages/store/src/lit/mixins/tests/combined-mixin.test.ts
index 2efa71e4..472a9673 100644
--- a/packages/store/src/lit/mixins/tests/combined-mixin.test.ts
+++ b/packages/store/src/lit/mixins/tests/combined-mixin.test.ts
@@ -27,7 +27,7 @@ describe('createStoreMixin', () => {
     await el.updateComplete;
 
     expect(el.store).toBeDefined();
-    expect(el.store.state).toEqual({ volume: 1, muted: false });
+    expect(el.store.state).toMatchObject({ volume: 1, muted: false });
   });
 
   it('auto-attaches slotted video element', async () => {
diff --git a/packages/store/src/lit/mixins/tests/provider-mixin.test.ts b/packages/store/src/lit/mixins/tests/provider-mixin.test.ts
index 75e8a288..93e8ce25 100644
--- a/packages/store/src/lit/mixins/tests/provider-mixin.test.ts
+++ b/packages/store/src/lit/mixins/tests/provider-mixin.test.ts
@@ -17,7 +17,7 @@ describe('createProviderMixin', () => {
     await el.updateComplete;
 
     expect(el.store).toBeDefined();
-    expect(el.store.state).toEqual({ volume: 1, muted: false });
+    expect(el.store.state).toMatchObject({ volume: 1, muted: false });
   });
 
   it('reuses same store instance', async () => {
diff --git a/packages/store/src/lit/store-accessor.ts b/packages/store/src/lit/store-accessor.ts
index 3dad99ae..c1f4de2a 100644
--- a/packages/store/src/lit/store-accessor.ts
+++ b/packages/store/src/lit/store-accessor.ts
@@ -39,7 +39,7 @@ export class StoreAccessor<Store extends AnyStore> {
 
     // Check if source is a store (object with subscribe) or context (symbol/string)
     if (isStore(source)) {
-      this.#directStore = source;
+      this.#directStore = source as Store;
       this.#consumer = null;
     } else {
       this.#directStore = null;
diff --git a/packages/store/src/lit/tests/create-store.test.ts b/packages/store/src/lit/tests/create-store.test.ts
index fabc2f33..55233b84 100644
--- a/packages/store/src/lit/tests/create-store.test.ts
+++ b/packages/store/src/lit/tests/create-store.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { createFeature } from '../../core/feature';
+import { defineFeature } from '../../core/feature';
 import { createStore } from '../create-store';
 import { TestBaseElement } from './test-utils';
 
@@ -11,8 +11,18 @@ describe('createStore', () => {
     muted = false;
   }
 
-  const audioFeature = createFeature<MockMedia>()({
-    initialState: { volume: 1, muted: false },
+  const audioFeature = defineFeature<MockMedia>()({
+    state: ({ task }) => ({
+      volume: 1,
+      muted: false,
+      setVolume(volume: number) {
+        return task(({ target }) => {
+          target.volume = volume;
+          target.dispatchEvent(new Event('volumechange'));
+          return volume;
+        });
+      },
+    }),
     getSnapshot: ({ target }) => ({
       volume: target.volume,
       muted: target.muted,
@@ -24,13 +34,6 @@ describe('createStore', () => {
         target.removeEventListener('volumechange', handler);
       });
     },
-    request: {
-      setVolume: (volume: number, { target }) => {
-        target.volume = volume;
-        target.dispatchEvent(new Event('volumechange'));
-        return volume;
-      },
-    },
   });
 
   describe('create', () => {
@@ -40,7 +43,7 @@ describe('createStore', () => {
       const store = create();
 
       expect(store).toBeDefined();
-      expect(store.state).toEqual({ volume: 1, muted: false });
+      expect(store.state).toMatchObject({ volume: 1, muted: false });
     });
 
     it('creates independent store instances', () => {
diff --git a/packages/store/src/lit/tests/store-accessor.test.ts b/packages/store/src/lit/tests/store-accessor.test.ts
index 7908336b..5b1d1ddb 100644
--- a/packages/store/src/lit/tests/store-accessor.test.ts
+++ b/packages/store/src/lit/tests/store-accessor.test.ts
@@ -59,6 +59,7 @@ describe('StoreAccessor', () => {
   describe('context source', () => {
     it('returns null when context not yet provided', () => {
       const host = createTestHost();
+
       // Use a symbol as context (this is what createContext returns)
       const fakeContext = Symbol('test-context') as any;
 
diff --git a/packages/store/src/lit/tests/test-utils.ts b/packages/store/src/lit/tests/test-utils.ts
index 4712e2eb..593f642d 100644
--- a/packages/store/src/lit/tests/test-utils.ts
+++ b/packages/store/src/lit/tests/test-utils.ts
@@ -1,8 +1,7 @@
 import { ReactiveElement } from '@lit/reactive-element';
 import { noop } from '@videojs/utils/function';
 import { afterEach } from 'vitest';
-import type { AnyFeature } from '../../core/feature';
-import { createFeature } from '../../core/feature';
+import { defineFeature } from '../../core/feature';
 import type { Store } from '../../core/store';
 import { createStore as createCoreStore } from '../../core/store';
 import { createStore as createLitStore } from '../create-store';
@@ -28,8 +27,33 @@ export class MockMedia extends EventTarget {
   muted = false;
 }
 
-export const audioFeature = createFeature<MockMedia>()({
-  initialState: { volume: 1, muted: false },
+export const audioFeature = defineFeature<MockMedia>()({
+  state: ({ task }) => ({
+    volume: 1,
+    muted: false,
+    setVolume(volume: number) {
+      return task(({ target }) => {
+        target.volume = volume;
+        target.dispatchEvent(new Event('volumechange'));
+        return volume;
+      });
+    },
+    setMuted(muted: boolean) {
+      return task(({ target }) => {
+        target.muted = muted;
+        target.dispatchEvent(new Event('volumechange'));
+        return muted;
+      });
+    },
+    slowSetVolume(volume: number) {
+      return task(async ({ target }) => {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        target.volume = volume;
+        target.dispatchEvent(new Event('volumechange'));
+        return volume;
+      });
+    },
+  }),
   getSnapshot: ({ target }) => ({
     volume: target.volume,
     muted: target.muted,
@@ -41,29 +65,38 @@ export const audioFeature = createFeature<MockMedia>()({
       target.removeEventListener('volumechange', handler);
     });
   },
-  request: {
-    setVolume: (volume: number, { target }): number => {
-      target.volume = volume;
-      target.dispatchEvent(new Event('volumechange'));
-      return volume;
-    },
-    setMuted: (muted: boolean, { target }): boolean => {
-      target.muted = muted;
-      target.dispatchEvent(new Event('volumechange'));
-      return muted;
-    },
-    slowSetVolume: async (volume: number, { target }): Promise<number> => {
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      target.volume = volume;
-      target.dispatchEvent(new Event('volumechange'));
-      return volume;
-    },
-  },
 });
 
 /** Feature with custom keys (name !== key) for testing superseding behavior. */
-export const customKeyFeature = createFeature<MockMedia>()({
-  initialState: { volume: 1, muted: false },
+export const customKeyFeature = defineFeature<MockMedia>()({
+  state: ({ task }) => ({
+    volume: 1,
+    muted: false,
+    // name='adjustVolume', key='audio-settings'
+    adjustVolume(volume: number) {
+      return task({
+        key: 'audio-settings',
+        async handler({ target }) {
+          await new Promise((resolve) => setTimeout(resolve, 20));
+          target.volume = volume;
+          target.dispatchEvent(new Event('volumechange'));
+          return volume;
+        },
+      });
+    },
+    // name='toggleMute', key='audio-settings' (same key - will supersede adjustVolume)
+    toggleMute(muted: boolean) {
+      return task({
+        key: 'audio-settings',
+        async handler({ target }) {
+          await new Promise((resolve) => setTimeout(resolve, 20));
+          target.muted = muted;
+          target.dispatchEvent(new Event('volumechange'));
+          return muted;
+        },
+      });
+    },
+  }),
   getSnapshot: ({ target }) => ({
     volume: target.volume,
     muted: target.muted,
@@ -75,57 +108,50 @@ export const customKeyFeature = createFeature<MockMedia>()({
       target.removeEventListener('volumechange', handler);
     });
   },
-  request: {
-    // name='adjustVolume', key='audio-settings'
-    adjustVolume: {
-      key: 'audio-settings',
-      handler: async (volume: number, { target }): Promise<number> => {
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        target.volume = volume;
-        target.dispatchEvent(new Event('volumechange'));
-        return volume;
-      },
-    },
-    // name='toggleMute', key='audio-settings' (same key - will supersede adjustVolume)
-    toggleMute: {
-      key: 'audio-settings',
-      handler: async (muted: boolean, { target }): Promise<boolean> => {
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        target.muted = muted;
-        target.dispatchEvent(new Event('volumechange'));
-        return muted;
-      },
-    },
-  },
 });
 
 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>;
+};
+
 // For controller tests - creates core store with attached target
-export function createCoreTestStore(): { store: Store<MockMedia, [TestFeature]>; target: MockMedia } {
+export function createCoreTestStore(): { store: TestStore; target: MockMedia } {
   const store = createCoreStore({
-    features: [audioFeature] as [AnyFeature],
+    features: [audioFeature],
     onError: noop,
   });
 
   const target = new MockMedia();
   store.attach(target);
 
-  return { store, target };
+  return { store: store as TestStore, target };
 }
 
 /** Creates store with custom key feature (name !== key) for testing superseding. */
-export function createCustomKeyTestStore(): { store: Store<MockMedia, [CustomKeyFeature]>; target: MockMedia } {
+export function createCustomKeyTestStore(): { store: CustomKeyStore; target: MockMedia } {
   const store = createCoreStore({
-    features: [customKeyFeature] as [AnyFeature],
+    features: [customKeyFeature],
     onError: noop,
   });
 
   const target = new MockMedia();
   store.attach(target);
 
-  return { store, target };
+  return { store: store as CustomKeyStore, target };
 }
 
 // For mixin tests - creates lit store factory
diff --git a/packages/store/src/lit/types.ts b/packages/store/src/lit/types.ts
new file mode 100644
index 00000000..23ca9e9f
--- /dev/null
+++ b/packages/store/src/lit/types.ts
@@ -0,0 +1,10 @@
+import type { AnyFeature } from '../core/feature';
+import type { Store } from '../core/store';
+
+export interface StoreProvider<Features extends AnyFeature[]> {
+  store: Store<Features>;
+}
+
+export interface StoreConsumer<Features extends AnyFeature[]> {
+  readonly store: Store<Features> | null;
+}
diff --git a/packages/store/src/react/create-store.tsx b/packages/store/src/react/create-store.tsx
index 744556d9..e4df1b1a 100644
--- a/packages/store/src/react/create-store.tsx
+++ b/packages/store/src/react/create-store.tsx
@@ -1,35 +1,23 @@
 import { isUndefined } from '@videojs/utils/predicate';
 import type { FC, ReactNode } from 'react';
 import { useEffect, useState } from 'react';
-import type { AnyFeature, UnionFeatureRequests, UnionFeatureState, UnionFeatureTarget } from '../core/feature';
-import type { StoreConfig } from '../core/store';
-
-import { Store } from '../core/store';
+import type { StoreConfig } from '../core/config';
+import type { AnyFeature, UnionFeatureState } from '../core/feature';
+import type { Store } from '../core/store';
+import { createStore as createCoreStore } from '../core/store';
 import { StoreContextProvider, useStoreContext } from './context';
 import { useStore as useStoreBase } from './hooks/use-store';
 
-// ----------------------------------------
-// Types
-// ----------------------------------------
-
-export interface CreateStoreConfig<Features extends AnyFeature[]>
-  extends StoreConfig<UnionFeatureTarget<Features>, Features> {
-  /** Display name for React DevTools. */
+export interface CreateStoreConfig<Features extends AnyFeature[]> extends StoreConfig<Features> {
   displayName?: string;
 }
 
 export interface ProviderProps<Features extends AnyFeature[]> {
   children: ReactNode;
-  /**
-   * Optional pre-created store instance.
-   * If provided, the Provider will use this store instead of creating one.
-   * The Provider will NOT destroy this store on unmount.
-   */
-  store?: Store<UnionFeatureTarget<Features>, Features>;
+  store?: Store<Features>;
 }
 
-export type UseStoreResult<Features extends AnyFeature[]> = UnionFeatureState<Features> &
-  UnionFeatureRequests<Features>;
+export type UseStoreResult<Features extends AnyFeature[]> = UnionFeatureState<Features>;
 
 export interface CreateStoreResult<Features extends AnyFeature[]> {
   /** Provider component that creates and manages the store lifecycle. */
@@ -45,7 +33,7 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
    * Creates a new store instance.
    * Useful for imperative access or creating a store before render.
    */
-  create: () => Store<UnionFeatureTarget<Features>, Features>;
+  create: () => Store<Features>;
 }
 
 // ----------------------------------------
@@ -68,11 +56,10 @@ export interface CreateStoreResult<Features extends AnyFeature[]> {
 export function createStore<Features extends AnyFeature[]>(
   config: CreateStoreConfig<Features>
 ): CreateStoreResult<Features> {
-  type Target = UnionFeatureTarget<Features>;
-  type StoreType = Store<Target, Features>;
+  type StoreType = Store<Features>;
 
   function create(): StoreType {
-    return new Store(config);
+    return createCoreStore(config);
   }
 
   /**
diff --git a/packages/store/src/react/hooks/index.ts b/packages/store/src/react/hooks/index.ts
index 8af57778..1411677f 100644
--- a/packages/store/src/react/hooks/index.ts
+++ b/packages/store/src/react/hooks/index.ts
@@ -1,4 +1 @@
-export type { AsyncStatus } from '../../shared/types';
-
-export { useSnapshot } from './use-snapshot';
 export { useStore } from './use-store';
diff --git a/packages/store/src/react/hooks/tests/test-utils.ts b/packages/store/src/react/hooks/tests/test-utils.ts
index 5a66a9e7..453faf7c 100644
--- a/packages/store/src/react/hooks/tests/test-utils.ts
+++ b/packages/store/src/react/hooks/tests/test-utils.ts
@@ -1,6 +1,6 @@
 import { noop } from '@videojs/utils/function';
 
-import { createFeature } from '../../../core/feature';
+import { defineFeature } from '../../../core/feature';
 import { createStore as createCoreStore } from '../../../core/store';
 
 // Shared mock target for synchronous tests
@@ -10,8 +10,25 @@ export class MockMedia extends EventTarget {
 }
 
 // Shared feature for synchronous tests
-export const audioFeature = createFeature<MockMedia>()({
-  initialState: { volume: 1, muted: false },
+export const audioFeature = defineFeature<MockMedia>()({
+  state: ({ task }) => ({
+    volume: 1,
+    muted: false,
+    setVolume(volume: number) {
+      return task(({ target }) => {
+        target.volume = volume;
+        target.dispatchEvent(new Event('volumechange'));
+        return volume;
+      });
+    },
+    setMuted(muted: boolean) {
+      return task(({ target }) => {
+        target.muted = muted;
+        target.dispatchEvent(new Event('volumechange'));
+        return muted;
+      });
+    },
+  }),
   getSnapshot: ({ target }) => ({
     volume: target.volume,
     muted: target.muted,
@@ -22,18 +39,6 @@ export const audioFeature = createFeature<MockMedia>()({
       target.removeEventListener('volumechange', update);
     });
   },
-  request: {
-    setVolume: (volume: number, { target }) => {
-      target.volume = volume;
-      target.dispatchEvent(new Event('volumechange'));
-      return volume;
-    },
-    setMuted: (muted: boolean, { target }) => {
-      target.muted = muted;
-      target.dispatchEvent(new Event('volumechange'));
-      return muted;
-    },
-  },
 });
 
 export function createTestStore() {
@@ -49,8 +54,39 @@ export class AsyncMockMedia extends EventTarget {
   muted = false;
 }
 
-export const asyncAudioFeature = createFeature<AsyncMockMedia>()({
-  initialState: { volume: 1, muted: false },
+export const asyncAudioFeature = defineFeature<AsyncMockMedia>()({
+  state: ({ task }) => ({
+    volume: 1,
+    muted: false,
+    setVolume(volume: number) {
+      return task(async ({ target }) => {
+        await Promise.resolve();
+        target.volume = volume;
+        target.dispatchEvent(new Event('volumechange'));
+        return volume;
+      });
+    },
+    slowSetVolume(volume: number) {
+      return task(async ({ target }) => {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        target.volume = volume;
+        target.dispatchEvent(new Event('volumechange'));
+        return volume;
+      });
+    },
+    failingRequest() {
+      return task(async () => {
+        await Promise.resolve();
+        throw new Error('Request failed');
+      });
+    },
+    failingSetVolume() {
+      return task(async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        throw new Error('Test error');
+      });
+    },
+  }),
   getSnapshot: ({ target }) => ({
     volume: target.volume,
     muted: target.muted,
@@ -62,36 +98,6 @@ export const asyncAudioFeature = createFeature<AsyncMockMedia>()({
       target.removeEventListener('volumechange', handler);
     });
   },
-  request: {
-    setVolume: {
-      handler: async (volume: number, { target }) => {
-        await Promise.resolve();
-        target.volume = volume;
-        target.dispatchEvent(new Event('volumechange'));
-        return volume;
-      },
-    },
-    slowSetVolume: {
-      handler: async (volume: number, { target }) => {
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        target.volume = volume;
-        target.dispatchEvent(new Event('volumechange'));
-        return volume;
-      },
-    },
-    failingRequest: {
-      handler: async () => {
-        await Promise.resolve();
-        throw new Error('Request failed');
-      },
-    },
-    failingSetVolume: {
-      handler: async () => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        throw new Error('Test error');
-      },
-    },
-  },
 });
 
 export function createAsyncTestStore() {
@@ -107,8 +113,35 @@ export function createAsyncTestStore() {
 }
 
 /** Feature with custom keys (name !== key) for testing superseding behavior. */
-export const customKeyFeature = createFeature<MockMedia>()({
-  initialState: { volume: 1, muted: false },
+export const customKeyFeature = defineFeature<MockMedia>()({
+  state: ({ task }) => ({
+    volume: 1,
+    muted: false,
+    // name='adjustVolume', key='audio-settings'
+    adjustVolume(volume: number) {
+      return task({
+        key: 'audio-settings',
+        async handler({ target }) {
+          await new Promise((resolve) => setTimeout(resolve, 20));
+          target.volume = volume;
+          target.dispatchEvent(new Event('volumechange'));
+          return volume;
+        },
+      });
+    },
+    // name='toggleMute', key='audio-settings' (same key - will supersede adjustVolume)
+    toggleMute(muted: boolean) {
+      return task({
+        key: 'audio-settings',
+        async handler({ target }) {
+          await new Promise((resolve) => setTimeout(resolve, 20));
+          target.muted = muted;
+          target.dispatchEvent(new Event('volumechange'));
+          return muted;
+        },
+      });
+    },
+  }),
   getSnapshot: ({ target }) => ({
     volume: target.volume,
     muted: target.muted,
@@ -120,28 +153,6 @@ export const customKeyFeature = createFeature<MockMedia>()({
       target.removeEventListener('volumechange', handler);
     });
   },
-  request: {
-    // name='adjustVolume', key='audio-settings'
-    adjustVolume: {
-      key: 'audio-settings',
-      handler: async (volume: number, { target }): Promise<number> => {
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        target.volume = volume;
-        target.dispatchEvent(new Event('volumechange'));
-        return volume;
-      },
-    },
-    // name='toggleMute', key='audio-settings' (same key - will supersede adjustVolume)
-    toggleMute: {
-      key: 'audio-settings',
-      handler: async (muted: boolean, { target }): Promise<boolean> => {
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        target.muted = muted;
-        target.dispatchEvent(new Event('volumechange'));
-        return muted;
-      },
-    },
-  },
 });
 
 export function createCustomKeyTestStore() {
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 c9718ae4..c7d6efa3 100644
--- a/packages/store/src/react/hooks/tests/use-store.test.tsx
+++ b/packages/store/src/react/hooks/tests/use-store.test.tsx
@@ -4,11 +4,18 @@ import { describe, expect, it } from 'vitest';
 import { useStore } from '../use-store';
 import { createTestStore } from './test-utils';
 
+interface AudioState {
+  volume: number;
+  muted: boolean;
+  setVolume: (volume: number) => Promise<number>;
+  setMuted: (muted: boolean) => Promise<boolean>;
+}
+
 describe('useStore', () => {
-  it('returns state and request functions spread together', () => {
+  it('returns state and action functions spread together', () => {
     const { store } = createTestStore();
 
-    const { result } = renderHook(() => useStore(store));
+    const { result } = renderHook(() => useStore(store) as AudioState);
 
     expect(result.current.volume).toBe(1);
     expect(result.current.muted).toBe(false);
@@ -18,7 +25,7 @@ describe('useStore', () => {
   it('updates when state changes', async () => {
     const { store } = createTestStore();
 
-    const { result } = renderHook(() => useStore(store));
+    const { result } = renderHook(() => useStore(store) as AudioState);
 
     expect(result.current.volume).toBe(1);
 
diff --git a/packages/store/src/react/hooks/use-snapshot.ts b/packages/store/src/react/hooks/use-snapshot.ts
deleted file mode 100644
index e019a47a..00000000
--- a/packages/store/src/react/hooks/use-snapshot.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { useSyncExternalStore } from 'react';
-import type { State } from '../../core/state';
-
-/**
- * Subscribe to state and re-render when state changes.
- *
- * @example
- * ```tsx
- * function VolumeDisplay() {
- *   const { volume } = useSnapshot(store.state);
- *   return <span>{Math.round(volume * 100)}%</span>;
- * }
- * ```
- */
-export function useSnapshot<T extends object>(state: State<T>): T {
-  return useSyncExternalStore(
-    (cb) => state.subscribe(cb),
-    () => state.current,
-    () => state.current
-  );
-}
-
-export namespace useSnapshot {
-  export type Result<T extends object> = T;
-}
diff --git a/packages/store/src/react/hooks/use-store.ts b/packages/store/src/react/hooks/use-store.ts
index 1c11c7ba..ea7baa08 100644
--- a/packages/store/src/react/hooks/use-store.ts
+++ b/packages/store/src/react/hooks/use-store.ts
@@ -1,12 +1,12 @@
-import { useMemo, useSyncExternalStore } from 'react';
-import type { AnyStore, InferStoreRequests, InferStoreState } from '../../core/store';
+import { useSyncExternalStore } from 'react';
+import type { AnyStore, InferStoreState } from '../../core/store';
 
-export type UseStoreResult<Store extends AnyStore> = InferStoreState<Store> & InferStoreRequests<Store>;
+export type UseStoreResult<S extends AnyStore> = InferStoreState<S>;
 
 /**
  * Subscribe to store state changes.
  *
- * Returns state and request functions spread together, re-renders when state changes.
+ * Returns state and action functions, re-renders when state changes.
  *
  * @example
  * ```tsx
@@ -22,16 +22,17 @@ export type UseStoreResult<Store extends AnyStore> = InferStoreState<Store> & In
  * }
  * ```
  */
-export function useStore<Store extends AnyStore>(store: Store): UseStoreResult<Store> {
-  const state = useSyncExternalStore(
+export function useStore<S extends AnyStore>(store: S): UseStoreResult<S> {
+  useSyncExternalStore(
     (cb) => store.subscribe(cb),
     () => store.state,
     () => store.state
   );
 
-  return useMemo(() => ({ ...state, ...store.request }) as UseStoreResult<Store>, [state, store.request]);
+  // In v2, state and actions are directly on the store object
+  return store as unknown as UseStoreResult<S>;
 }
 
 export namespace useStore {
-  export type Result<Store extends AnyStore> = UseStoreResult<Store>;
+  export type Result<S extends AnyStore> = UseStoreResult<S>;
 }
diff --git a/packages/store/src/react/index.ts b/packages/store/src/react/index.ts
index 6a29d3ff..923432b8 100644
--- a/packages/store/src/react/index.ts
+++ b/packages/store/src/react/index.ts
@@ -6,4 +6,4 @@ export type {
 } from './create-store';
 export { createStore } from './create-store';
 
-export { useSnapshot, useStore } from './hooks';
+export { useStore } from './hooks';
diff --git a/packages/store/src/react/tests/context.test.tsx b/packages/store/src/react/tests/context.test.tsx
index 6014657f..aa606707 100644
--- a/packages/store/src/react/tests/context.test.tsx
+++ b/packages/store/src/react/tests/context.test.tsx
@@ -3,7 +3,7 @@ import type { ReactNode } from 'react';
 
 import { describe, expect, it } from 'vitest';
 
-import { createFeature } from '../../core/feature';
+import { defineFeature } from '../../core/feature';
 import { createStore as createCoreStore } from '../../core/store';
 import { StoreContextProvider, useStoreContext } from '../context';
 
@@ -13,11 +13,12 @@ describe('context', () => {
     volume = 1;
   }
 
-  const audioFeature = createFeature<MockMedia>()({
-    initialState: { volume: 1 },
+  const audioFeature = defineFeature<MockMedia>()({
+    state: () => ({
+      volume: 1,
+    }),
     getSnapshot: ({ target }) => ({ volume: target.volume }),
     subscribe: () => {},
-    request: {},
   });
 
   describe('useStoreContext', () => {
diff --git a/packages/store/src/react/tests/create-store.test.tsx b/packages/store/src/react/tests/create-store.test.tsx
index 37e6d0f6..54450673 100644
--- a/packages/store/src/react/tests/create-store.test.tsx
+++ b/packages/store/src/react/tests/create-store.test.tsx
@@ -3,9 +3,15 @@ import type { ReactNode } from 'react';
 
 import { describe, expect, it } from 'vitest';
 
-import { createFeature } from '../../core/feature';
+import { defineFeature } from '../../core/feature';
 import { createStore } from '../create-store';
 
+interface AudioState {
+  volume: number;
+  muted: boolean;
+  setVolume: (volume: number) => Promise<number>;
+}
+
 describe('createStore', () => {
   // Mock target
   class MockMedia extends EventTarget {
@@ -13,8 +19,18 @@ describe('createStore', () => {
     muted = false;
   }
 
-  const audioFeature = createFeature<MockMedia>()({
-    initialState: { volume: 1, muted: false },
+  const audioFeature = defineFeature<MockMedia>()({
+    state: ({ task }) => ({
+      volume: 1,
+      muted: false,
+      setVolume(volume: number) {
+        return task(({ target }) => {
+          target.volume = volume;
+          target.dispatchEvent(new Event('volumechange'));
+          return volume;
+        });
+      },
+    }),
     getSnapshot: ({ target }) => ({
       volume: target.volume,
       muted: target.muted,
@@ -25,13 +41,6 @@ describe('createStore', () => {
         target.removeEventListener('volumechange', update);
       });
     },
-    request: {
-      setVolume: (volume: number, { target }) => {
-        target.volume = volume;
-        target.dispatchEvent(new Event('volumechange'));
-        return volume;
-      },
-    },
   });
 
   describe('create', () => {
@@ -41,7 +50,7 @@ describe('createStore', () => {
       const store = create();
 
       expect(store).toBeDefined();
-      expect(store.state).toEqual({ volume: 1, muted: false });
+      expect(store.state).toMatchObject({ volume: 1, muted: false });
     });
   });
 
@@ -49,7 +58,7 @@ describe('createStore', () => {
     it('creates store on mount', () => {
       const { Provider, useStore } = createStore({ features: [audioFeature] });
 
-      const { result } = renderHook(() => useStore(), {
+      const { result } = renderHook(() => useStore() as AudioState, {
         wrapper: ({ children }: { children: ReactNode }) => <Provider>{children}</Provider>,
       });
 
@@ -85,7 +94,7 @@ describe('createStore', () => {
   });
 
   describe('useStore', () => {
-    it('returns state and request functions from context', () => {
+    it('returns state and action functions from context', () => {
       const { Provider, useStore, create } = createStore({
         features: [audioFeature],
       });
@@ -93,7 +102,7 @@ describe('createStore', () => {
       const target = new MockMedia();
       store.attach(target);
 
-      const { result } = renderHook(() => useStore(), {
+      const { result } = renderHook(() => useStore() as AudioState, {
         wrapper: ({ children }: { children: ReactNode }) => <Provider store={store}>{children}</Provider>,
       });
 
@@ -110,7 +119,7 @@ describe('createStore', () => {
       const target = new MockMedia();
       store.attach(target);
 
-      const { result } = renderHook(() => useStore(), {
+      const { result } = renderHook(() => useStore() as AudioState, {
         wrapper: ({ children }: { children: ReactNode }) => <Provider store={store}>{children}</Provider>,
       });
 
diff --git a/packages/store/src/shared/types.ts b/packages/store/src/shared/types.ts
deleted file mode 100644
index 5a99df64..00000000
--- a/packages/store/src/shared/types.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-/**
- * Lifecycle status for async operations.
- *
- * - `'idle'` — Operation hasn't started yet
- * - `'pending'` — Operation is in flight
- * - `'success'` — Operation completed successfully
- * - `'error'` — Operation failed with an error
- */
-export type AsyncStatus = 'idle' | 'pending' | 'success' | 'error';
diff --git a/packages/utils/src/function/noop.ts b/packages/utils/src/function/noop.ts
index 89966dd3..bcf0253f 100644
--- a/packages/utils/src/function/noop.ts
+++ b/packages/utils/src/function/noop.ts
@@ -1 +1 @@
-export function noop(): void {}
+export function noop(..._args: unknown[]): void {}
diff --git a/packages/utils/src/types/types.ts b/packages/utils/src/types/types.ts
index 7492effa..3baac0ff 100644
--- a/packages/utils/src/types/types.ts
+++ b/packages/utils/src/types/types.ts
@@ -13,3 +13,6 @@ export type Mixin<Base, Result> = <T extends Constructor<Base>>(Base: T) => T &
 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] } & {};