diff --git a/.changeset/focused-vue-subscriptions.md b/.changeset/focused-vue-subscriptions.md
new file mode 100644
index 0000000..955f1ea
--- /dev/null
+++ b/.changeset/focused-vue-subscriptions.md
@@ -0,0 +1,16 @@
+---
+'@codebelt/classy-store': patch
+---
+
+Update Vue snapshot refs synchronously so computed values are immediately current
+and one `await nextTick()` waits for the resulting DOM update. Vue rendering and
+ordinary core subscriptions still batch.
+
+Require an active Vue effect scope for `useClassyStore()` and stop delivery when
+that scope is disposed, including disposal during notification. Call the hook in
+`setup()` / `<script setup>` or `effectScope().run()`; calls without an active
+scope now throw instead of creating a subscription with no cleanup owner.
+
+Correct the Vue peer dependency to 3.2 or later, matching the Effect Scope APIs
+used by the adapter. Add regressions for inputs, writable computed models, class
+getters, keyed lists, timing, and component cleanup.
diff --git a/bun.lock b/bun.lock
index d60e098..1de4ada 100644
--- a/bun.lock
+++ b/bun.lock
@@ -142,7 +142,7 @@
         "react": ">=18.0.0",
         "solid-js": ">=1.0.0",
         "svelte": ">=4.0.0",
-        "vue": ">=3.0.0",
+        "vue": ">=3.2.0",
       },
       "optionalPeers": [
         "@angular/core",
diff --git a/examples/vue/package.json b/examples/vue/package.json
index 2d45ea6..fb018cd 100644
--- a/examples/vue/package.json
+++ b/examples/vue/package.json
@@ -6,7 +6,8 @@
   "scripts": {
     "dev": "vite",
     "build": "vue-tsc -b && vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "check:integration": "vue-tsc --project ../../packages/classy-store/tests/browser/vue/tsconfig.json --noEmit"
   },
   "dependencies": {
     "@codebelt/classy-store": "workspace:*",
diff --git a/package.json b/package.json
index c680b07..945e8b8 100644
--- a/package.json
+++ b/package.json
@@ -21,7 +21,7 @@
     "---------- Lint --------------------------------------------------------": "",
     "lint": "biome check",
     "lint:fix": "biome check --write",
-    "typecheck": "bun run --filter @codebelt/classy-store typecheck && bun run --filter @codebelt/classy-store typecheck:scoping && bun run --filter classy-store-svelte-example check:integration",
+    "typecheck": "bun run --filter @codebelt/classy-store typecheck && bun run --filter @codebelt/classy-store typecheck:scoping && bun run --filter classy-store-svelte-example check:integration && bun run --filter classy-store-vue-example check:integration",
     "---------- Release (Changesets) ----------------------------------------": "",
     "changeset": "changeset",
     "changeset:add": "changeset add",
diff --git a/packages/classy-store/package.json b/packages/classy-store/package.json
index 807245e..efe0e42 100644
--- a/packages/classy-store/package.json
+++ b/packages/classy-store/package.json
@@ -130,7 +130,7 @@
   },
   "peerDependencies": {
     "react": ">=18.0.0",
-    "vue": ">=3.0.0",
+    "vue": ">=3.2.0",
     "svelte": ">=4.0.0",
     "@angular/core": ">=17.0.0",
     "solid-js": ">=1.0.0"
diff --git a/packages/classy-store/src/frameworks/vue/vue.test.ts b/packages/classy-store/src/frameworks/vue/vue.test.ts
index 94e941e..e5df76b 100644
--- a/packages/classy-store/src/frameworks/vue/vue.test.ts
+++ b/packages/classy-store/src/frameworks/vue/vue.test.ts
@@ -1,63 +1,144 @@
-import {describe, expect, it} from 'bun:test';
-import {effectScope} from 'vue';
-import {createClassyStore} from '../../core/core';
+import {describe, expect, it, mock} from 'bun:test';
+import {computed, effectScope, isShallow, nextTick, watch} from 'vue';
+import {createClassyStore, getInternal, subscribe} from '../../core/core';
+import {snapshot} from '../../snapshot/snapshot';
 import {useClassyStore} from './vue';
 
-const flush = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
-
 describe('vue useClassyStore', () => {
   it('throws when given a non-store object', () => {
     const scope = effectScope();
     try {
-      scope.run(() => {
-        expect(() => useClassyStore({count: 0})).toThrow(/not a store proxy/);
-      });
+      scope.run(() =>
+        expect(() => useClassyStore({count: 0})).toThrow(/not a store proxy/),
+      );
     } finally {
       scope.stop();
     }
   });
 
-  it('returns a ShallowRef holding the current snapshot', () => {
-    const s = createClassyStore({count: 5});
+  it('rejects calls without an active scope before subscribing', () => {
+    const store = createClassyStore({count: 0});
+    expect(() => useClassyStore(store)).toThrow(/active.*scope/i);
+    expect(getInternal(store).syncListeners.size).toBe(0);
+    expect(getInternal(store).batchedListeners.size).toBe(0);
+  });
+
+  it('rejects calls after the current scope has stopped', () => {
+    const store = createClassyStore({count: 0});
+    const scope = effectScope();
+    scope.run(() => {
+      scope.stop();
+      expect(() => useClassyStore(store)).toThrow(/active.*scope/i);
+    });
+    expect(getInternal(store).syncListeners.size).toBe(0);
+    expect(getInternal(store).batchedListeners.size).toBe(0);
+  });
+
+  it('returns a shallow ref containing the current immutable snapshot', () => {
+    const store = createClassyStore({count: 5, nested: {label: 'Initial'}});
     const scope = effectScope();
     try {
-      scope.run(() => {
-        const state = useClassyStore(s);
-        expect(state.value).toEqual({count: 5});
-      });
+      const state = scope.run(() => useClassyStore(store));
+      expect(isShallow(state)).toBe(true);
+      expect(state?.value).toBe(snapshot(store));
+      expect(Object.isFrozen(state?.value)).toBe(true);
+      expect(Object.isFrozen(state?.value.nested)).toBe(true);
     } finally {
       scope.stop();
     }
   });
 
-  it('updates the ref when the store mutates', async () => {
-    const s = createClassyStore({count: 0});
+  it('updates refs and computed values synchronously while Vue watchers and core subscriptions batch', async () => {
+    const store = createClassyStore({count: 0});
     const scope = effectScope();
-    let stateRef!: ReturnType<typeof useClassyStore<typeof s>>;
-    scope.run(() => {
-      stateRef = useClassyStore(s);
+    const coreCallback = mock(() => {});
+    const stopCore = subscribe(store, coreCallback);
+    const watcher = mock(() => {});
+    const result = scope.run(() => {
+      const state = useClassyStore(store);
+      watch(state, watcher);
+      return {state, doubled: computed(() => state.value.count * 2)};
     });
-
-    s.count = 42;
-    await flush();
-    expect(stateRef.value).toEqual({count: 42});
-    scope.stop();
+    if (!result) throw new Error('Missing scope result');
+    try {
+      store.count = 1;
+      expect(result.state.value.count).toBe(1);
+      expect(result.doubled.value).toBe(2);
+      store.count = 2;
+      expect(result.state.value.count).toBe(2);
+      expect(result.doubled.value).toBe(4);
+      expect(coreCallback).not.toHaveBeenCalled();
+      expect(watcher).not.toHaveBeenCalled();
+      await nextTick();
+      expect(coreCallback).toHaveBeenCalledTimes(1);
+      expect(watcher).toHaveBeenCalledTimes(1);
+    } finally {
+      scope.stop();
+      stopCore();
+    }
   });
 
-  it('unsubscribes when the effect scope is stopped', async () => {
-    const s = createClassyStore({count: 0});
+  it('flushes Vue post effects after a single nextTick following a store mutation', async () => {
+    const store = createClassyStore({count: 0});
     const scope = effectScope();
-    let stateRef!: ReturnType<typeof useClassyStore<typeof s>>;
+    const rendered: number[] = [];
     scope.run(() => {
-      stateRef = useClassyStore(s);
+      const state = useClassyStore(store);
+      watch(state, (value) => rendered.push(value.count), {flush: 'post'});
     });
+    try {
+      store.count = 1;
+      await nextTick();
+      expect(rendered).toEqual([1]);
+    } finally {
+      scope.stop();
+    }
+  });
 
-    scope.stop();
+  it('cleans up each scope independently and reads fresh state on remount', async () => {
+    const store = createClassyStore({count: 0});
+    const firstScope = effectScope();
+    const secondScope = effectScope();
+    const first = firstScope.run(() => useClassyStore(store));
+    const second = secondScope.run(() => useClassyStore(store));
+    if (!first || !second) throw new Error('Missing scope result');
+    try {
+      store.count = 1;
+      firstScope.stop();
+      firstScope.stop();
+      store.count = 2;
+      await nextTick();
+      expect(first.value.count).toBe(1);
+      expect(second.value.count).toBe(2);
+    } finally {
+      firstScope.stop();
+      secondScope.stop();
+    }
+    expect(getInternal(store).syncListeners.size).toBe(0);
+    expect(getInternal(store).batchedListeners.size).toBe(0);
+    const remountedScope = effectScope();
+    try {
+      const remounted = remountedScope.run(() => useClassyStore(store));
+      expect(remounted?.value.count).toBe(2);
+    } finally {
+      remountedScope.stop();
+    }
+  });
 
-    const before = stateRef.value;
-    s.count = 999;
-    await flush();
-    // After unmount, ref should not update further.
-    expect(stateRef.value).toBe(before);
+  it('does not update a ref whose scope is stopped during the same notification', async () => {
+    const store = createClassyStore({count: 0});
+    const scope = effectScope();
+    const stop = subscribe(store, () => scope.stop(), {sync: true});
+    const state = scope.run(() => useClassyStore(store));
+    try {
+      store.count = 1;
+      await nextTick();
+      expect(state?.value.count).toBe(0);
+    } finally {
+      scope.stop();
+      stop();
+    }
+    expect(getInternal(store).syncListeners.size).toBe(0);
+    expect(getInternal(store).batchedListeners.size).toBe(0);
   });
 });
diff --git a/packages/classy-store/src/frameworks/vue/vue.ts b/packages/classy-store/src/frameworks/vue/vue.ts
index d78687f..25d22f3 100644
--- a/packages/classy-store/src/frameworks/vue/vue.ts
+++ b/packages/classy-store/src/frameworks/vue/vue.ts
@@ -1,25 +1,45 @@
-import {onScopeDispose, type ShallowRef, shallowRef} from 'vue';
+import {
+  getCurrentScope,
+  onScopeDispose,
+  type ShallowRef,
+  shallowRef,
+} from 'vue';
 import {getInternal, subscribe} from '../../core/core';
 import {snapshot} from '../../snapshot/snapshot';
 import type {Snapshot} from '../../types';
 
+/**
+ * Read immutable snapshots from a shallow ref inside setup() or an active
+ * effect scope. Ref updates are synchronous; Vue batches rendering normally.
+ * The scope owns subscription cleanup.
+ */
 export function useClassyStore<T extends object>(
   proxyStore: T,
 ): ShallowRef<Snapshot<T>> {
-  // Validate up front so users get a clear error instead of an opaque trace.
   getInternal(proxyStore);
+  if (!getCurrentScope()?.active) {
+    throw new Error(
+      '@codebelt/classy-store/vue: useClassyStore() requires an active Vue effect scope; call it in setup() or effectScope().run()',
+    );
+  }
 
   const state = shallowRef(snapshot(proxyStore)) as unknown as ShallowRef<
     Snapshot<T>
   >;
+  let active = true;
+  const unsubscribe = subscribe(
+    proxyStore,
+    () => {
+      // A prior subscriber may stop this scope during the same notification.
+      if (active) state.value = snapshot(proxyStore);
+    },
+    {sync: true},
+  );
 
-  const unsubscribe = subscribe(proxyStore, () => {
-    state.value = snapshot(proxyStore);
+  onScopeDispose(() => {
+    active = false;
+    unsubscribe();
   });
 
-  // `onScopeDispose` runs both on component unmount (setup() runs inside a
-  // scope) and on standalone `effectScope().stop()`.
-  onScopeDispose(unsubscribe);
-
   return state;
 }
diff --git a/packages/classy-store/tests/browser/README.md b/packages/classy-store/tests/browser/README.md
index cf71d7d..984e0dc 100644
--- a/packages/classy-store/tests/browser/README.md
+++ b/packages/classy-store/tests/browser/README.md
@@ -9,7 +9,7 @@ bunx playwright install chromium firefox webkit
 bun run test:browser
 ```
 
-CI also installs the Linux system dependencies with `playwright install --with-deps`. The suite starts an isolated local Bun server and tests the source React and Svelte bindings in Chromium, Firefox, and WebKit. Package exports and React version compatibility are tested separately in `tests/compatibility`.
+CI also installs the Linux system dependencies with `playwright install --with-deps`. The suite starts an isolated local Bun server and tests the source React, Vue, and Svelte bindings in Chromium, Firefox, and WebKit. Package exports and React version compatibility are tested separately in `tests/compatibility`.
 
 The `/svelte` fixture compiles a Svelte 5 component using real `$store`
 subscriptions and `$derived` values. Four cases cover input caret behavior,
@@ -24,6 +24,17 @@ Root `bun run typecheck` checks the fixture through the Svelte example's
 the current `svelte-check` requires the JavaScript TypeScript compiler API;
 the library's TypeScript 7 installation supplies the native compiler instead.
 
+The `/vue` fixture compiles a Vue single-file component with `vue/compiler-sfc`.
+Four cases cover text caret behavior, writable computed `v-model` inputs and a
+checkbox, same-event computed reads and one-`nextTick()` DOM updates, keyed list
+changes, and three mount/unmount cycles with pending renders. It also verifies
+one render and one ordinary core notification for a multi-property action.
+Before the adapter fix, the DOM read immediately after `await nextTick()` still
+contained the old text and computed value. Vue warnings fail the fixture.
+Run these cases with `bun run test:browser vue.spec.ts`; root `bun run typecheck`
+checks its template through the Vue example's `check:integration` script using
+that example's Vue tooling and TypeScript installation.
+
 Every test fails on browser console errors or uncaught page errors. Native clipboard replacement and subsequent caret behavior are tested in Chromium; Firefox and WebKit explicitly skip those cases because they do not expose the same clipboard permissions API.
 
 The `/persistence` fixture opens two pages in one browser context and uses real
diff --git a/packages/classy-store/tests/browser/server.ts b/packages/classy-store/tests/browser/server.ts
index 6c08b36..18dafa6 100644
--- a/packages/classy-store/tests/browser/server.ts
+++ b/packages/classy-store/tests/browser/server.ts
@@ -1,5 +1,6 @@
 import {fileURLToPath} from 'node:url';
 import {compile} from 'svelte/compiler';
+import {compileScript, parse} from 'vue/compiler-sfc';
 import {compileConsumer} from '../compiler/compileConsumer.mjs';
 import {
   releaseStreamingBoundary,
@@ -93,12 +94,55 @@ if (!svelteBundle.success)
   );
 const svelteScript = await svelteBundle.outputs[0].text();
 
+const vueBundle = await Bun.build({
+  entrypoints: [fileURLToPath(new URL('./vue/client.ts', import.meta.url))],
+  target: 'browser',
+  format: 'iife',
+  define: {
+    'process.env.NODE_ENV': '"development"',
+    __VUE_OPTIONS_API__: 'true',
+    __VUE_PROD_DEVTOOLS__: 'false',
+    __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: 'false',
+  },
+  plugins: [
+    {
+      name: 'vue-consumer',
+      setup(build) {
+        build.onLoad({filter: /\.vue$/}, async ({path}) => {
+          const {descriptor, errors} = parse(await Bun.file(path).text(), {
+            filename: path,
+          });
+          if (errors.length)
+            throw new AggregateError(errors, 'Could not parse Vue fixture');
+          const {content} = compileScript(descriptor, {
+            id: 'classy-vue-fixture',
+            inlineTemplate: true,
+          });
+          return {contents: content, loader: 'ts'};
+        });
+      },
+    },
+  ],
+});
+if (!vueBundle.success)
+  throw new AggregateError(vueBundle.logs, 'Could not bundle Vue fixture');
+const vueScript = await vueBundle.outputs[0].text();
+
 Bun.serve({
   hostname: '127.0.0.1',
   port: 4179,
   routes: {
     '/': page,
     '/persistence': persistencePage,
+    '/vue': () =>
+      new Response(
+        '<!doctype html><html><head><meta charset="utf-8"><title>Vue consumer</title></head><body><div id="vue-root"></div><script src="/vue/client.js"></script></body></html>',
+        {headers: {'Content-Type': 'text/html; charset=utf-8'}},
+      ),
+    '/vue/client.js': () =>
+      new Response(vueScript, {
+        headers: {'Content-Type': 'text/javascript; charset=utf-8'},
+      }),
     '/svelte': () =>
       new Response(
         '<!doctype html><html><head><meta charset="utf-8"><title>Svelte consumer</title></head><body><div id="svelte-root"></div><script src="/svelte/client.js"></script></body></html>',
diff --git a/packages/classy-store/tests/browser/vue.spec.ts b/packages/classy-store/tests/browser/vue.spec.ts
new file mode 100644
index 0000000..30de149
--- /dev/null
+++ b/packages/classy-store/tests/browser/vue.spec.ts
@@ -0,0 +1,110 @@
+import {expect} from '@playwright/test';
+import {test} from './browser.test';
+
+test.beforeEach(async ({page}) => {
+  await page.goto('/vue');
+  await expect(page.getByLabel('Text', {exact: true})).toHaveValue('abcdef');
+});
+
+test('Vue inputs preserve the caret and support writable computed models', async ({
+  page,
+}) => {
+  const input = page.getByLabel('Text', {exact: true});
+  await input.focus();
+  await input.evaluate((element: HTMLInputElement) =>
+    element.setSelectionRange(2, 2),
+  );
+  await input.pressSequentially('XY');
+  await expect(input).toHaveValue('abXYcdef');
+  expect(
+    await input.evaluate((element: HTMLInputElement) => element.selectionStart),
+  ).toBe(4);
+  await expect(page.getByTestId('uppercase')).toHaveText('ABXYCDEF');
+  await expect(page.getByLabel('Text model')).toHaveValue('abXYcdef');
+  await input.evaluate((element: HTMLInputElement) =>
+    element.setSelectionRange(2, 4),
+  );
+  await input.pressSequentially('Z');
+  await expect(input).toHaveValue('abZcdef');
+  expect(
+    await input.evaluate((element: HTMLInputElement) => element.selectionStart),
+  ).toBe(3);
+  await input.press('Backspace');
+  await expect(input).toHaveValue('abcdef');
+  await page.getByLabel('Text model').fill('model edit');
+  await expect(input).toHaveValue('model edit');
+  await expect(page.getByTestId('uppercase')).toHaveText('MODEL EDIT');
+  await page.getByLabel('Enabled').check();
+  await expect(page.getByTestId('enabled')).toHaveText('true');
+  await page.getByLabel('Enabled').uncheck();
+  await expect(page.getByTestId('enabled')).toHaveText('false');
+  await page.evaluate(() => window.vueProbe.setText('external'));
+  await expect(input).toHaveValue('external');
+  await expect(page.getByLabel('Text model')).toHaveValue('external');
+});
+
+test('Vue updates refs immediately and the DOM after one nextTick while core subscriptions batch', async ({
+  page,
+}) => {
+  await expect(page.getByTestId('summary')).toHaveText('abcdef:2:ABCDEF');
+  await page.getByRole('button', {name: 'Update together'}).click();
+  await expect(page.getByTestId('summary')).toHaveText('updated:6:UPDATED');
+  const state = await page.evaluate(() => window.vueProbe.getState());
+  expect(state.summaryAfterNextTick).toBe('updated:6:UPDATED');
+  expect(state.snapshotDuringEvent).toBe('updated:6:UPDATED');
+  expect(state.coreDuringEvent).toBe(0);
+  expect(state.coreNotifications).toBe(1);
+  expect(state.commits).toEqual(['abcdef:2:ABCDEF', 'updated:6:UPDATED']);
+});
+
+test('Vue keyed lists handle insertion, nested edits, removal, and replacement', async ({
+  page,
+}) => {
+  const items = page.getByRole('listitem');
+  await expect(items).toHaveText(['One', 'Two']);
+  await page.getByRole('button', {name: 'Add item'}).click();
+  await expect(items).toHaveText(['One', 'Two', 'Three']);
+  await expect(page.getByTestId('item-count')).toHaveText('3');
+  await page.getByRole('button', {name: 'Rename first'}).click();
+  await expect(items).toHaveText(['Renamed', 'Two', 'Three']);
+  await page.getByRole('button', {name: 'Remove first'}).click();
+  await expect(items).toHaveText(['Two', 'Three']);
+  await expect(page.getByTestId('item-count')).toHaveText('2');
+  await page.getByRole('button', {name: 'Replace items'}).click();
+  await expect(items).toHaveText(['Four']);
+  await expect(page.getByTestId('item-count')).toHaveText('1');
+});
+
+test('Vue unmount cancels pending renders and releases subscriptions across remounts', async ({
+  page,
+}) => {
+  for (let cycle = 0; cycle < 3; cycle += 1) {
+    expect(await page.evaluate(() => window.vueProbe.getState())).toMatchObject(
+      {syncListeners: 1, batchedListeners: 1},
+    );
+    const commits = await page.evaluate(() => {
+      const count = window.vueProbe.getState().commits.length;
+      window.vueProbe.setText('pending');
+      window.vueProbe.unmount();
+      return count;
+    });
+    await expect(page.getByLabel('Text', {exact: true})).toHaveCount(0);
+    expect(await page.evaluate(() => window.vueProbe.getState())).toMatchObject(
+      {syncListeners: 0, batchedListeners: 1},
+    );
+    await page.evaluate(
+      (value) => window.vueProbe.setText(value),
+      `unmounted-${cycle}`,
+    );
+    expect(
+      await page.evaluate(() => window.vueProbe.getState().commits.length),
+    ).toBe(commits);
+    await page.evaluate(() => window.vueProbe.mount());
+    await expect(page.getByLabel('Text', {exact: true})).toHaveValue(
+      `unmounted-${cycle}`,
+    );
+    await expect(page.getByTestId('uppercase')).toHaveText(
+      `UNMOUNTED-${cycle}`,
+    );
+  }
+});
diff --git a/packages/classy-store/tests/browser/vue/VueForm.vue b/packages/classy-store/tests/browser/vue/VueForm.vue
new file mode 100644
index 0000000..99824db
--- /dev/null
+++ b/packages/classy-store/tests/browser/vue/VueForm.vue
@@ -0,0 +1,51 @@
+<script setup lang="ts">
+import {computed, nextTick, onMounted, onUpdated} from 'vue';
+import {useClassyStore} from '../../../src/frameworks/vue/vue';
+import {formStore, probe} from './vue.store';
+
+const snap = useClassyStore(formStore);
+const uppercase = computed(() => snap.value.text.toUpperCase());
+const itemCount = computed(() => snap.value.items.length);
+const summary = computed(
+  () => `${snap.value.text}:${snap.value.doubled}:${uppercase.value}`,
+);
+const textModel = computed({
+  get: () => snap.value.text,
+  set: (value: string) => formStore.setText(value),
+});
+const enabledModel = computed({
+  get: () => snap.value.enabled,
+  set: (value: boolean) => formStore.setEnabled(value),
+});
+
+function handleInput(event: Event) {
+  formStore.setText((event.target as HTMLInputElement).value);
+}
+async function handleUpdateTogether() {
+  formStore.updateTogether();
+  probe.snapshotDuringEvent = summary.value;
+  probe.coreDuringEvent = probe.coreNotifications;
+  await nextTick();
+  probe.summaryAfterNextTick =
+    document.querySelector('[data-testid="summary"]')?.textContent ?? '';
+}
+onMounted(() => probe.commits.push(summary.value));
+onUpdated(() => probe.commits.push(summary.value));
+</script>
+
+<template>
+  <label>Text <input :value="snap.text" @input="handleInput" /></label>
+  <label>Text model <input v-model="textModel" /></label>
+  <label>Enabled <input type="checkbox" v-model="enabledModel" /></label>
+  <output data-testid="enabled">{{ snap.enabled }}</output>
+  <output data-testid="text">{{ snap.text }}</output>
+  <output data-testid="uppercase">{{ uppercase }}</output>
+  <output data-testid="summary">{{ summary }}</output>
+  <output data-testid="item-count">{{ itemCount }}</output>
+  <button @click="handleUpdateTogether">Update together</button>
+  <button @click="formStore.addItem()">Add item</button>
+  <button @click="formStore.renameFirst()">Rename first</button>
+  <button @click="formStore.removeFirst()">Remove first</button>
+  <button @click="formStore.replaceItems()">Replace items</button>
+  <ul><li v-for="item in snap.items" :key="item.id">{{ item.label }}</li></ul>
+</template>
diff --git a/packages/classy-store/tests/browser/vue/client.ts b/packages/classy-store/tests/browser/vue/client.ts
new file mode 100644
index 0000000..860148f
--- /dev/null
+++ b/packages/classy-store/tests/browser/vue/client.ts
@@ -0,0 +1,31 @@
+import {createApp} from 'vue';
+import VueForm from './VueForm.vue';
+import {formStore, getProbe} from './vue.store';
+
+const target = document.getElementById('vue-root');
+if (!target) throw new Error('Missing Vue root');
+let app: ReturnType<typeof createApp> | undefined;
+const vueProbe = {
+  getState: getProbe,
+  setText: (text: string) => formStore.setText(text),
+  mount() {
+    if (app) throw new Error('Vue fixture is already mounted');
+    app = createApp(VueForm);
+    app.config.warnHandler = (message) => {
+      throw new Error(`Vue warning: ${message}`);
+    };
+    app.mount(target);
+  },
+  unmount() {
+    if (!app) throw new Error('Vue fixture is not mounted');
+    app.unmount();
+    app = undefined;
+  },
+};
+declare global {
+  interface Window {
+    vueProbe: typeof vueProbe;
+  }
+}
+window.vueProbe = vueProbe;
+vueProbe.mount();
diff --git a/packages/classy-store/tests/browser/vue/env.d.ts b/packages/classy-store/tests/browser/vue/env.d.ts
new file mode 100644
index 0000000..f3ac333
--- /dev/null
+++ b/packages/classy-store/tests/browser/vue/env.d.ts
@@ -0,0 +1,5 @@
+declare module '*.vue' {
+  import type {DefineComponent} from 'vue';
+  const component: DefineComponent;
+  export default component;
+}
diff --git a/packages/classy-store/tests/browser/vue/tsconfig.json b/packages/classy-store/tests/browser/vue/tsconfig.json
new file mode 100644
index 0000000..738f142
--- /dev/null
+++ b/packages/classy-store/tests/browser/vue/tsconfig.json
@@ -0,0 +1,5 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {"jsx": "preserve"},
+  "include": ["**/*.ts", "**/*.vue"]
+}
diff --git a/packages/classy-store/tests/browser/vue/vue.store.ts b/packages/classy-store/tests/browser/vue/vue.store.ts
new file mode 100644
index 0000000..d3410a8
--- /dev/null
+++ b/packages/classy-store/tests/browser/vue/vue.store.ts
@@ -0,0 +1,61 @@
+import {
+  createClassyStore,
+  getInternal,
+  subscribe,
+} from '../../../src/core/core';
+
+class FormStore {
+  text = 'abcdef';
+  count = 1;
+  enabled = false;
+  items = [
+    {id: 1, label: 'One'},
+    {id: 2, label: 'Two'},
+  ];
+
+  get doubled() {
+    return this.count * 2;
+  }
+  setText(text: string) {
+    this.text = text;
+  }
+  setEnabled(enabled: boolean) {
+    this.enabled = enabled;
+  }
+  updateTogether() {
+    this.text = 'updated';
+    this.count = 3;
+  }
+  addItem() {
+    this.items.push({id: 3, label: 'Three'});
+  }
+  renameFirst() {
+    this.items[0].label = 'Renamed';
+  }
+  removeFirst() {
+    this.items.splice(0, 1);
+  }
+  replaceItems() {
+    this.items = [{id: 4, label: 'Four'}];
+  }
+}
+
+export const formStore = createClassyStore(new FormStore());
+export const probe = {
+  coreNotifications: 0,
+  coreDuringEvent: -1,
+  snapshotDuringEvent: '',
+  summaryAfterNextTick: '',
+  commits: [] as string[],
+};
+subscribe(formStore, () => {
+  probe.coreNotifications += 1;
+});
+
+export function getProbe() {
+  return {
+    ...probe,
+    syncListeners: getInternal(formStore).syncListeners.size,
+    batchedListeners: getInternal(formStore).batchedListeners.size,
+  };
+}
diff --git a/website/docs/ARCHITECTURE.md b/website/docs/ARCHITECTURE.md
index 0ff7d03..d6c9439 100644
--- a/website/docs/ARCHITECTURE.md
+++ b/website/docs/ARCHITECTURE.md
@@ -138,7 +138,7 @@ root. This guide and the utility architecture guides live in `website/docs`.
 
 ### Overview
 
-The `createClassyStore()` function wraps a class instance in an ES6 Proxy. Assignments and deletions through that proxy, including array operations and supported nested state, are intercepted. Raw-object writes and descriptor changes bypass these traps. Subscribers are batched by default into one microtask notification, while React and Svelte use the synchronous path.
+The `createClassyStore()` function wraps a class instance in an ES6 Proxy. Assignments and deletions through that proxy, including array operations and supported nested state, are intercepted. Raw-object writes and descriptor changes bypass these traps. Subscribers are batched by default into one microtask notification, while React, Vue, and Svelte use the synchronous path.
 
 ### Data Flow: Mutation → Notification
 
@@ -221,6 +221,11 @@ inside that first callback are observed, and removes the subscription if the
 initial callback throws. Normal unsubscription stops delivery even if another
 subscriber removes it during an in-progress notification.
 
+The Vue adapter updates its shallow ref synchronously too. Vue handles render
+batching, and `nextTick()` then waits for the queued DOM update. The hook requires
+an active component or effect scope to own cleanup, and ignores notifications if
+that scope has been disposed during an in-progress notification.
+
 ### Version Propagation
 
 When a nested property mutates, versions bump from the mutated node up to the root:
diff --git a/website/docs/TUTORIAL.md b/website/docs/TUTORIAL.md
index 137e46a..2d3daac 100644
--- a/website/docs/TUTORIAL.md
+++ b/website/docs/TUTORIAL.md
@@ -1,6 +1,6 @@
 # Classy Store Tutorial
 
-`Classy Store` is a reactive state library for React, Vue, Svelte, Solid, and Angular built on ES proxies. Define state as classes, wrap them with `createClassyStore()`, and read them with the binding for your framework. Shared client stores need no Provider, observer, or reducer; context providers can scope independent instances. The library batches ordinary subscriptions while notifying React and Svelte synchronously, and uses structural sharing for change detection.
+`Classy Store` is a reactive state library for React, Vue, Svelte, Solid, and Angular built on ES proxies. Define state as classes, wrap them with `createClassyStore()`, and read them with the binding for your framework. Shared client stores need no Provider, observer, or reducer; context providers can scope independent instances. The library batches ordinary subscriptions while notifying React, Vue, and Svelte synchronously, and uses structural sharing for change detection.
 
 ## Quick Start
 
diff --git a/website/docs/index.md b/website/docs/index.md
index 56e3f61..8522be5 100644
--- a/website/docs/index.md
+++ b/website/docs/index.md
@@ -36,7 +36,7 @@ All framework peer dependencies are optional — install only what your project
 | Framework | Peer Dependency | Import |
 |-----------|----------------|--------|
 | React | `react >= 18.0.0` | `@codebelt/classy-store/react` |
-| Vue | `vue >= 3.0.0` | `@codebelt/classy-store/vue` |
+| Vue | `vue >= 3.2.0` | `@codebelt/classy-store/vue` |
 | Svelte | `svelte >= 4.0.0` | `@codebelt/classy-store/svelte` |
 | Solid | `solid-js >= 1.0.0` | `@codebelt/classy-store/solid` |
 | Angular | `@angular/core >= 17.0.0` | `@codebelt/classy-store/angular` |
@@ -165,14 +165,24 @@ notifies subscribers synchronously after each mutation. `$store` subscriptions
 are cleaned up automatically when the component is destroyed; manual subscribers
 must call the returned unsubscribe function. Snapshots are readonly: update the
 original store or call its actions from input handlers instead of using
-`bind:value` on snapshot fields. Vue, Solid, Angular, and ordinary core
-subscriptions use microtask batching.
+`bind:value` on snapshot fields. Solid, Angular, and ordinary core subscriptions
+use microtask batching.
+
+Vue's `useClassyStore(store)` updates its `ShallowRef` synchronously, so computed
+values are current immediately after an action and `await nextTick()` waits for
+Vue's DOM update. Vue still batches rendering. Call the hook synchronously in
+`setup()` / `<script setup>` or inside `effectScope().run()`; it throws without an
+active scope, and stops subscribing when that scope is stopped. For inputs, use
+`:value` with an action in `@input`, or a writable `computed` that reads the
+snapshot and writes through a store action. Do not bind `v-model` directly to
+readonly snapshot fields. The Vue adapter requires Vue 3.2 or later for the
+Effect Scope API.
 
 ## API Reference
 
 ### `createClassyStore(instance)`
 
-Wraps a class instance in a reactive Proxy. Mutations notify React and Svelte immediately; ordinary subscribers are batched via `queueMicrotask`.
+Wraps a class instance in a reactive Proxy. Mutations notify React, Vue, and Svelte immediately; ordinary subscribers are batched via `queueMicrotask`.
 
 ```typescript
 const myStore = createClassyStore(new MyClass());
diff --git a/website/static/llms-full.txt b/website/static/llms-full.txt
index a71211f..947f59d 100644
--- a/website/static/llms-full.txt
+++ b/website/static/llms-full.txt
@@ -45,7 +45,7 @@ All framework peer dependencies are optional — install only what your project
 | Framework | Peer Dependency | Import |
 |-----------|----------------|--------|
 | React | `react >= 18.0.0` | `@codebelt/classy-store/react` |
-| Vue | `vue >= 3.0.0` | `@codebelt/classy-store/vue` |
+| Vue | `vue >= 3.2.0` | `@codebelt/classy-store/vue` |
 | Svelte | `svelte >= 4.0.0` | `@codebelt/classy-store/svelte` |
 | Solid | `solid-js >= 1.0.0` | `@codebelt/classy-store/solid` |
 | Angular | `@angular/core >= 17.0.0` | `@codebelt/classy-store/angular` |
@@ -174,14 +174,24 @@ notifies subscribers synchronously after each mutation. `$store` subscriptions
 are cleaned up automatically when the component is destroyed; manual subscribers
 must call the returned unsubscribe function. Snapshots are readonly: update the
 original store or call its actions from input handlers instead of using
-`bind:value` on snapshot fields. Vue, Solid, Angular, and ordinary core
-subscriptions use microtask batching.
+`bind:value` on snapshot fields. Solid, Angular, and ordinary core subscriptions
+use microtask batching.
+
+Vue's `useClassyStore(store)` updates its `ShallowRef` synchronously, so computed
+values are current immediately after an action and `await nextTick()` waits for
+Vue's DOM update. Vue still batches rendering. Call the hook synchronously in
+`setup()` / `<script setup>` or inside `effectScope().run()`; it throws without an
+active scope, and stops subscribing when that scope is stopped. For inputs, use
+`:value` with an action in `@input`, or a writable `computed` that reads the
+snapshot and writes through a store action. Do not bind `v-model` directly to
+readonly snapshot fields. The Vue adapter requires Vue 3.2 or later for the
+Effect Scope API.
 
 ## API Reference
 
 ### `createClassyStore(instance)`
 
-Wraps a class instance in a reactive Proxy. Mutations notify React and Svelte immediately; ordinary subscribers are batched via `queueMicrotask`.
+Wraps a class instance in a reactive Proxy. Mutations notify React, Vue, and Svelte immediately; ordinary subscribers are batched via `queueMicrotask`.
 
 ```typescript
 const myStore = createClassyStore(new MyClass());
@@ -985,7 +995,7 @@ SOURCE: https://codebelt.github.io/classy-store/docs/TUTORIAL
 
 # Classy Store Tutorial
 
-`Classy Store` is a reactive state library for React, Vue, Svelte, Solid, and Angular built on ES proxies. Define state as classes, wrap them with `createClassyStore()`, and read them with the binding for your framework. Shared client stores need no Provider, observer, or reducer; context providers can scope independent instances. The library batches ordinary subscriptions while notifying React and Svelte synchronously, and uses structural sharing for change detection.
+`Classy Store` is a reactive state library for React, Vue, Svelte, Solid, and Angular built on ES proxies. Define state as classes, wrap them with `createClassyStore()`, and read them with the binding for your framework. Shared client stores need no Provider, observer, or reducer; context providers can scope independent instances. The library batches ordinary subscriptions while notifying React, Vue, and Svelte synchronously, and uses structural sharing for change detection.
 
 ## Quick Start
 
@@ -1752,7 +1762,7 @@ root. This guide and the utility architecture guides live in `website/docs`.
 
 ### Overview
 
-The `createClassyStore()` function wraps a class instance in an ES6 Proxy. Assignments and deletions through that proxy, including array operations and supported nested state, are intercepted. Raw-object writes and descriptor changes bypass these traps. Subscribers are batched by default into one microtask notification, while React and Svelte use the synchronous path.
+The `createClassyStore()` function wraps a class instance in an ES6 Proxy. Assignments and deletions through that proxy, including array operations and supported nested state, are intercepted. Raw-object writes and descriptor changes bypass these traps. Subscribers are batched by default into one microtask notification, while React, Vue, and Svelte use the synchronous path.
 
 ### Data Flow: Mutation → Notification
 
@@ -1835,6 +1845,11 @@ inside that first callback are observed, and removes the subscription if the
 initial callback throws. Normal unsubscription stops delivery even if another
 subscriber removes it during an in-progress notification.
 
+The Vue adapter updates its shallow ref synchronously too. Vue handles render
+batching, and `nextTick()` then waits for the queued DOM update. The hook requires
+an active component or effect scope to own cleanup, and ignores notifications if
+that scope has been disposed during an in-progress notification.
+
 ### Version Propagation
 
 When a nested property mutates, versions bump from the mutated node up to the root: