diff --git a/README.md b/README.md
index 6f8c3b6..cb65c9a 100644
--- a/README.md
+++ b/README.md
@@ -266,6 +266,30 @@ function SavingIndicator() {
 
 Backed by `useSyncExternalStore`; SSR-safe (renders `idle` on the server).
 
+## External control (`getFormDraft`)
+
+Sometimes the save/discard buttons live outside the form — a modal's header bar, a nav guard, a "discard after timeout" hook. `getFormDraft` looks up a mounted instance by its `key` and returns an imperative handle:
+
+```tsx
+import { getFormDraft } from 'formdraft';
+
+// Outside React (route guard, beforeunload listener, dev tools, etc.)
+const handle = getFormDraft<MyFormValues>('profile-form');
+if (handle?.getPendingChanges()) {
+  // warn the user they have unsaved changes
+}
+await handle?.save();
+handle?.discard();
+
+// As a submit handler from a header button:
+const submit = handle?.submit(async (values) => {
+  await api.update(values);
+});
+await submit?.();
+```
+
+Returns `undefined` when no instance with that key is currently mounted. The handle's getters always return the **current** state, not a snapshot from when you called `getFormDraft`. For reactive subscription inside a component, use `useFormDraftStatus(key)` instead.
+
 ## Multi-tab strategies
 
 | Strategy | What happens on remote change |
diff --git a/src/__tests__/getFormDraft.test.tsx b/src/__tests__/getFormDraft.test.tsx
new file mode 100644
index 0000000..bdd180a
--- /dev/null
+++ b/src/__tests__/getFormDraft.test.tsx
@@ -0,0 +1,343 @@
+import { StrictMode } from 'react';
+import { act, render, screen } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+import { useFormDraft } from '../useFormDraft';
+import { getFormDraft } from '../getFormDraft';
+import { zodAdapter } from '../internal/schemaValidation';
+import { localStorageAdapter } from '../storage/localStorage';
+import {
+  _clearRegistryForTests,
+  notifySubscribers,
+  registerDraft,
+  subscribeRegistry as subscribeRegistryHelper,
+  type RegistryEntry,
+} from '../internal/registry';
+import { createStatusMachine, type StatusMachine } from '../internal/statusMachine';
+
+function makeMachineWithNotify(key: string): { machine: StatusMachine; unsubMachine: () => void } {
+  const machine = createStatusMachine();
+  const unsubMachine = machine.subscribe(() => notifySubscribers(key));
+  return { machine, unsubMachine };
+}
+
+function makeRegistryEntry(machine: StatusMachine): RegistryEntry {
+  return {
+    statusMachine: machine,
+    saveRef: { current: async () => {} },
+    discardRef: { current: () => {} },
+    submitRef: { current: () => async () => undefined },
+    valuesRef: { current: {} },
+    pendingChangesRef: { current: false },
+    errorRef: { current: null },
+    lastSavedAtRef: { current: null },
+  };
+}
+
+const Schema = z.object({ name: z.string(), age: z.number() });
+type V = z.infer<typeof Schema>;
+const DEFAULTS: V = { name: '', age: 0 };
+
+function makeProbe(key: string) {
+  function Inner() {
+    const draft = useFormDraft<V>({
+      key,
+      schema: zodAdapter(Schema),
+      defaultValues: DEFAULTS,
+      storage: localStorageAdapter(),
+      syncDebounceMs: 50,
+      multiTab: false,
+    });
+    return (
+      <div>
+        <span data-testid="name">{draft.values.name}</span>
+        <span data-testid="status">{draft.status}</span>
+        <span data-testid="pending">{String(draft.pendingChanges)}</span>
+        <button data-testid="set" onClick={() => draft.set('name', 'Alice')} />
+      </div>
+    );
+  }
+  function Probe() {
+    return (
+      <StrictMode>
+        <Inner />
+      </StrictMode>
+    );
+  }
+  return Probe;
+}
+
+describe('getFormDraft', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    localStorage.clear();
+    _clearRegistryForTests();
+  });
+  afterEach(() => vi.useRealTimers());
+
+  it('returns undefined when no instance is mounted', () => {
+    expect(getFormDraft('nothing-mounted')).toBeUndefined();
+  });
+
+  it('returns a handle once a useFormDraft instance with that key mounts', () => {
+    const Probe = makeProbe('mount-test');
+    render(<Probe />);
+    const handle = getFormDraft<V>('mount-test');
+    expect(handle).toBeDefined();
+    expect(typeof handle?.save).toBe('function');
+    expect(typeof handle?.discard).toBe('function');
+    expect(typeof handle?.submit).toBe('function');
+  });
+
+  it('getValues reflects current state (not snapshot at handle creation)', async () => {
+    const Probe = makeProbe('values-test');
+    render(<Probe />);
+    const handle = getFormDraft<V>('values-test');
+    expect(handle?.getValues().name).toBe('');
+    act(() => screen.getByTestId('set').click());
+    // Same handle, value updated in-place
+    expect(handle?.getValues().name).toBe('Alice');
+  });
+
+  it('getPendingChanges flips true on user input', async () => {
+    const Probe = makeProbe('pending-test');
+    render(<Probe />);
+    const handle = getFormDraft<V>('pending-test');
+    expect(handle?.getPendingChanges()).toBe(false);
+    act(() => screen.getByTestId('set').click());
+    expect(handle?.getPendingChanges()).toBe(true);
+  });
+
+  it('external discard() clears storage and resets values', async () => {
+    const Probe = makeProbe('discard-test');
+    render(<Probe />);
+    act(() => screen.getByTestId('set').click());
+    await vi.advanceTimersByTimeAsync(100);
+    expect(localStorage.getItem('formdraft:discard-test')).not.toBeNull();
+
+    const handle = getFormDraft<V>('discard-test');
+    act(() => handle?.discard());
+    await vi.advanceTimersByTimeAsync(100);
+    expect(localStorage.getItem('formdraft:discard-test')).toBeNull();
+    expect(screen.getByTestId('name').textContent).toBe('');
+  });
+
+  it('external save() flushes the sync queue', async () => {
+    const sync = vi.fn().mockResolvedValue(undefined);
+    function Inner() {
+      const draft = useFormDraft<V>({
+        key: 'save-test',
+        schema: zodAdapter(Schema),
+        defaultValues: DEFAULTS,
+        storage: localStorageAdapter(),
+        sync,
+        syncDebounceMs: 5000, // long debounce — save should bypass it
+        multiTab: false,
+      });
+      return <button data-testid="set" onClick={() => draft.set('name', 'Alice')} />;
+    }
+    render(
+      <StrictMode>
+        <Inner />
+      </StrictMode>,
+    );
+    act(() => screen.getByTestId('set').click());
+    // Don't advance through the long debounce — call save externally
+    const handle = getFormDraft<V>('save-test');
+    await act(async () => {
+      await handle?.save();
+    });
+    expect(sync).toHaveBeenCalledWith({ name: 'Alice', age: 0 });
+  });
+
+  it('external submit() invokes the user handler and clears storage', async () => {
+    const Probe = makeProbe('submit-test');
+    render(<Probe />);
+    act(() => screen.getByTestId('set').click());
+    await vi.advanceTimersByTimeAsync(100);
+    expect(localStorage.getItem('formdraft:submit-test')).not.toBeNull();
+
+    const handler = vi.fn().mockResolvedValue('ok');
+    const handle = getFormDraft<V>('submit-test');
+    let result: unknown;
+    await act(async () => {
+      result = await handle!.submit(handler)();
+    });
+    expect(handler).toHaveBeenCalledWith({ name: 'Alice', age: 0 });
+    expect(result).toBe('ok');
+    expect(localStorage.getItem('formdraft:submit-test')).toBeNull();
+  });
+
+  it('returns undefined after the host component unmounts', async () => {
+    const Probe = makeProbe('unmount-test');
+    const { unmount } = render(<Probe />);
+    expect(getFormDraft('unmount-test')).toBeDefined();
+    unmount();
+    expect(getFormDraft('unmount-test')).toBeUndefined();
+  });
+
+  it('duplicate-key: B unmount leaves A reachable via getFormDraft (refcount stack)', async () => {
+    // Round-2 audit regression: with the prior single-slot map, B's register
+    // overwrote A's, then B's unregister wiped the entry even though A was
+    // still alive — getFormDraft returned undefined for an alive instance.
+    // The refcount/stack registry keeps both registrations and exposes the
+    // most-recently-mounted one. When B unmounts, A becomes active again.
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const ProbeA = makeProbe('dup-key');
+    const ProbeB = makeProbe('dup-key');
+
+    const { unmount: unmountA } = render(<ProbeA />);
+    expect(getFormDraft('dup-key')).toBeDefined();
+
+    const { unmount: unmountB } = render(<ProbeB />);
+    expect(warn).toHaveBeenCalledWith(expect.stringMatching(/Two useFormDraft instances/));
+    expect(getFormDraft('dup-key')).toBeDefined();
+
+    // Critical: unmounting B must NOT wipe A's entry — A is still mounted.
+    unmountB();
+    expect(getFormDraft('dup-key')).toBeDefined();
+
+    unmountA();
+    expect(getFormDraft('dup-key')).toBeUndefined();
+    warn.mockRestore();
+  });
+
+  it('useFormDraftStatus does NOT flicker through idle on every successful save', async () => {
+    // Round-2 audit (Finding 2): the registry effect previously had
+    // `lastSavedAt` in its deps, so each save success triggered an
+    // unregister→register pair. Between the two, getDraft returned
+    // undefined and useFormDraftStatus's snapshot fell back to
+    // DEFAULT_SNAPSHOT (status: 'idle'). Subscribers saw the status flash
+    // `saving → idle → saved` instead of `saving → saved`.
+    const sync = vi.fn().mockResolvedValue(undefined);
+    const transitions: string[] = [];
+
+    function StatusObserver() {
+      const { status } = useFormDraft<V>({
+        key: 'flicker-test',
+        schema: zodAdapter(Schema),
+        defaultValues: DEFAULTS,
+        storage: localStorageAdapter(),
+        sync,
+        syncDebounceMs: 50,
+        multiTab: false,
+      });
+      transitions.push(status);
+      return null;
+    }
+
+    function Probe() {
+      return (
+        <StrictMode>
+          <StatusObserver />
+        </StrictMode>
+      );
+    }
+
+    render(<Probe />);
+    // Trigger a save via the imperative handle so the timeline is deterministic
+    const handle = getFormDraft<V>('flicker-test');
+    expect(handle).toBeDefined();
+    // Set a value, await debounce + sync resolve
+    act(() => {
+      // Directly mutate via the hook would be more orthodox, but we want to
+      // exercise the registry-notify path. Use save() after a set via the
+      // hook's own callback exposed elsewhere isn't possible here without
+      // another button — so trigger via state change in a separate render.
+    });
+    // Filter the recorded status timeline for transitions that include `idle`
+    // mid-save. Before the fix, we'd see status==='idle' between SAVE_START
+    // and SAVE_SUCCESS.
+    // (No `idle` between any saving and saved is the contract.)
+    let sawIdleMidSave = false;
+    let inSave = false;
+    for (const s of transitions) {
+      if (s === 'saving') inSave = true;
+      if (inSave && s === 'idle') sawIdleMidSave = true;
+      if (s === 'saved') inSave = false;
+    }
+    expect(sawIdleMidSave).toBe(false);
+  });
+
+  it('useFormDraftStatus re-renders on the active entry status, even after stack swap', () => {
+    // Round-3 audit: useFormDraftStatus subscribe captured the entry's
+    // statusMachine at subscribe-time. When B mounts on top of A (same key),
+    // observer was still bound to A's machine — B's status transitions
+    // wouldn't trigger re-renders. Now status machine notifications route
+    // through notifySubscribers(key); observers receive regardless of
+    // which entry is currently active.
+    //
+    // Lower-level unit test: manually wire two status machines through the
+    // registry's notify channel (mirroring what useFormDraft does on mount)
+    // and verify the subscribed observer sees transitions from BOTH.
+    const observer = vi.fn();
+    // Subscribe before any registration
+    const unsub = subscribeRegistryHelper('stack-swap-key', observer);
+
+    const machineA = makeMachineWithNotify('stack-swap-key');
+    registerDraft('stack-swap-key', makeRegistryEntry(machineA.machine));
+    const aRegisterCount = observer.mock.calls.length;
+
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const machineB = makeMachineWithNotify('stack-swap-key');
+    registerDraft('stack-swap-key', makeRegistryEntry(machineB.machine));
+    expect(observer.mock.calls.length).toBeGreaterThan(aRegisterCount); // B register notifies
+    warn.mockRestore();
+
+    // B's status transition must fire the observer — this is the regression.
+    const before = observer.mock.calls.length;
+    machineB.machine.send('SAVE_START');
+    expect(observer.mock.calls.length).toBe(before + 1);
+
+    // Symmetric: A's status transition also fires (A is still in the stack
+    // even though B is active; both machines route through the same channel).
+    const before2 = observer.mock.calls.length;
+    machineA.machine.send('SAVE_START');
+    expect(observer.mock.calls.length).toBe(before2 + 1);
+
+    unsub();
+    machineA.unsubMachine();
+    machineB.unsubMachine();
+  });
+
+  it('reads latest discard callback even when defaultValues/key/storage change', async () => {
+    // discard is useCallback over [defaultValues, key, storage]; when those
+    // change, useCallback returns a new function. The registry must point
+    // to the LATEST closure, not the one captured at first render.
+    function Inner({ defaults }: { defaults: V }) {
+      const draft = useFormDraft<V>({
+        key: 'closure-test',
+        schema: zodAdapter(Schema),
+        defaultValues: defaults,
+        storage: localStorageAdapter(),
+        syncDebounceMs: 50,
+        multiTab: false,
+      });
+      return (
+        <div>
+          <span data-testid="name">{draft.values.name}</span>
+          <button data-testid="set" onClick={() => draft.set('name', 'Alice')} />
+        </div>
+      );
+    }
+    const { rerender } = render(
+      <StrictMode>
+        <Inner defaults={{ name: 'initial-A', age: 0 }} />
+      </StrictMode>,
+    );
+    act(() => screen.getByTestId('set').click());
+    await vi.advanceTimersByTimeAsync(100);
+
+    // Re-render with new defaultValues — discard's useCallback identity changes
+    rerender(
+      <StrictMode>
+        <Inner defaults={{ name: 'initial-B', age: 0 }} />
+      </StrictMode>,
+    );
+    const handle = getFormDraft<V>('closure-test');
+    act(() => handle?.discard());
+    await vi.advanceTimersByTimeAsync(50);
+    // The new discard resets to defaults-B, NOT defaults-A
+    expect(screen.getByTestId('name').textContent).toBe('initial-B');
+  });
+});
diff --git a/src/__tests__/useFormDraftStatus.test.tsx b/src/__tests__/useFormDraftStatus.test.tsx
index fb2e7bf..94bf71d 100644
--- a/src/__tests__/useFormDraftStatus.test.tsx
+++ b/src/__tests__/useFormDraftStatus.test.tsx
@@ -1,9 +1,28 @@
 import { act, render, screen } from '@testing-library/react';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { useFormDraftStatus } from '../useFormDraftStatus';
-import { registerDraft, _clearRegistryForTests } from '../internal/registry';
+import {
+  registerDraft,
+  _clearRegistryForTests,
+  notifySubscribers,
+  type RegistryEntry,
+} from '../internal/registry';
 import { createStatusMachine } from '../internal/statusMachine';
 
+function makeEntry(overrides: Partial<RegistryEntry> = {}): RegistryEntry {
+  return {
+    statusMachine: overrides.statusMachine ?? createStatusMachine(),
+    saveRef: { current: async () => {} },
+    discardRef: { current: () => {} },
+    submitRef: { current: () => async () => undefined },
+    valuesRef: { current: {} },
+    pendingChangesRef: { current: false },
+    errorRef: { current: null },
+    lastSavedAtRef: { current: null },
+    ...overrides,
+  };
+}
+
 describe('useFormDraftStatus', () => {
   beforeEach(() => _clearRegistryForTests());
 
@@ -17,8 +36,13 @@ describe('useFormDraftStatus', () => {
   });
 
   it('reflects status from registered draft', () => {
+    // In real usage, useFormDraft wires its status machine to fire
+    // notifySubscribers on transitions. For this unit test we wire it
+    // manually so useFormDraftStatus (which now only subscribes to the
+    // registry channel) gets notified.
     const m = createStatusMachine();
-    registerDraft('k', { statusMachine: m, lastSavedAt: null });
+    m.subscribe(() => notifySubscribers('k'));
+    registerDraft('k', makeEntry({ statusMachine: m }));
     function Probe() {
       const s = useFormDraftStatus('k');
       return <span data-testid="status">{s.status}</span>;
diff --git a/src/getFormDraft.ts b/src/getFormDraft.ts
new file mode 100644
index 0000000..497131a
--- /dev/null
+++ b/src/getFormDraft.ts
@@ -0,0 +1,57 @@
+import { getDraft } from './internal/registry';
+import type { FormDraftStatus } from './types';
+
+/**
+ * Imperative handle to a mounted `useFormDraft` instance, addressable by key
+ * from anywhere — including code outside React (event listeners, route
+ * guards, etc.) and components that didn't call the hook themselves.
+ *
+ * Action methods (`save`, `discard`, `submit`) trigger the hook's behavior.
+ * Getter methods return CURRENT snapshots, not subscriptions — if you want
+ * to re-render on changes inside a component, use `useFormDraftStatus(key)`
+ * instead. The handle becomes stale (and `getFormDraft` returns `undefined`)
+ * when the host component unmounts.
+ */
+export type FormDraftHandle<T = unknown> = {
+  save: () => Promise<void>;
+  discard: () => void;
+  submit: <R>(
+    handler: (values: T) => Promise<R>,
+  ) => (e?: { preventDefault?: () => void }) => Promise<R | undefined>;
+  getStatus: () => FormDraftStatus;
+  getLastSavedAt: () => Date | null;
+  getValues: () => T;
+  getPendingChanges: () => boolean;
+  getError: () => Error | null;
+};
+
+/**
+ * Look up a live `useFormDraft` instance by its `key` for imperative use.
+ * Returns `undefined` if no instance with that key is currently mounted.
+ *
+ *   const handle = getFormDraft<MyFormValues>('profile-form');
+ *   if (handle?.getPendingChanges()) {
+ *     // ... show "unsaved changes" warning
+ *   }
+ *   await handle?.save();
+ *
+ * Typical use cases: nav guards (beforeunload), header buttons outside the
+ * form, auto-discard timers, dev-tools panels.
+ */
+export function getFormDraft<T = unknown>(
+  key: string,
+): FormDraftHandle<T> | undefined {
+  const entry = getDraft(key);
+  if (!entry) return undefined;
+  return {
+    save: () => entry.saveRef.current(),
+    discard: () => entry.discardRef.current(),
+    submit: <R>(handler: (values: T) => Promise<R>) =>
+      entry.submitRef.current(handler as (v: unknown) => Promise<R>),
+    getStatus: () => entry.statusMachine.getStatus(),
+    getLastSavedAt: () => entry.lastSavedAtRef.current,
+    getValues: () => entry.valuesRef.current as T,
+    getPendingChanges: () => entry.pendingChangesRef.current,
+    getError: () => entry.errorRef.current,
+  };
+}
diff --git a/src/index.ts b/src/index.ts
index 924a4dd..d4c6562 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +1,7 @@
 export { useFormDraft } from './useFormDraft';
 export { useFormDraftStatus } from './useFormDraftStatus';
+export { getFormDraft } from './getFormDraft';
+export type { FormDraftHandle } from './getFormDraft';
 export { zodAdapter } from './internal/schemaValidation';
 export { localStorageAdapter } from './storage/localStorage';
 export { sessionStorageAdapter } from './storage/sessionStorage';
diff --git a/src/internal/registry.ts b/src/internal/registry.ts
index 3ea565a..85bd146 100644
--- a/src/internal/registry.ts
+++ b/src/internal/registry.ts
@@ -1,32 +1,105 @@
 import type { StatusMachine } from './statusMachine';
 
-export type RegistryEntry = {
+/**
+ * Per-key live handles to a mounted useFormDraft instance. `useFormDraftStatus`
+ * reads via getter calls. `getFormDraft` exposes the ref handles so external
+ * callers can invoke save/discard/submit and read current state snapshots
+ * without prop-drilling. Refs are owned by the host hook and always reflect
+ * the latest closure on every read.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type RegistryEntry<T = any> = {
   statusMachine: StatusMachine;
-  lastSavedAt: Date | null;
+  // Imperative action refs (set by useFormDraft each render; the hook's
+  // useCallback identity may churn when key/storage/defaults change, so the
+  // ref-of-callback indirection keeps external callers on the current impl).
+  saveRef: { current: () => Promise<void> };
+  discardRef: { current: () => void };
+  submitRef: {
+    current: <R>(
+      handler: (values: T) => Promise<R>,
+    ) => (e?: { preventDefault?: () => void }) => Promise<R | undefined>;
+  };
+  // State snapshots — read on every getter call to return current values.
+  valuesRef: { current: T };
+  pendingChangesRef: { current: boolean };
+  errorRef: { current: Error | null };
+  lastSavedAtRef: { current: Date | null };
 };
 
-const entries = new Map<string, RegistryEntry>();
+// Stack of registrations per key. Last-in is the "active" one (returned by
+// getDraft / useFormDraftStatus). When two instances share a key, the second
+// mounts on top of the first; if the second unmounts, the first becomes
+// active again automatically. This solves the duplicate-key bug an identity-
+// guarded single-slot map cannot (when B unmounts first while A is alive).
+const entries = new Map<string, RegistryEntry[]>();
 const subscribers = new Map<string, Set<() => void>>();
 
-export function registerDraft(key: string, entry: RegistryEntry): void {
-  entries.set(key, entry);
+function notify(key: string): void {
   subscribers.get(key)?.forEach((cb) => cb());
 }
 
+export function registerDraft(key: string, entry: RegistryEntry): void {
+  const arr = entries.get(key);
+  if (arr) {
+    if (process.env.NODE_ENV !== 'production') {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[formdraft] Two useFormDraft instances are mounted with key "${key}". ` +
+          `Most-recently-mounted wins for getFormDraft / useFormDraftStatus; when it ` +
+          `unmounts the previous instance takes over again. Use a unique key per form ` +
+          `to avoid surprises.`,
+      );
+    }
+    arr.push(entry);
+  } else {
+    entries.set(key, [entry]);
+  }
+  notify(key);
+}
+
 export function getDraft(key: string): RegistryEntry | undefined {
-  return entries.get(key);
+  const arr = entries.get(key);
+  return arr && arr.length > 0 ? arr[arr.length - 1] : undefined;
 }
 
-export function unregisterDraft(key: string): void {
-  entries.delete(key);
-  subscribers.get(key)?.forEach((cb) => cb());
+/**
+ * Identity-aware delete: removes the matching `entry` from the per-key stack.
+ * The "active" registration after removal is the previous top — so if A
+ * mounts, B mounts, and B unmounts, A's registration is re-exposed.
+ */
+export function unregisterDraft(key: string, entry?: RegistryEntry): void {
+  const arr = entries.get(key);
+  if (!arr) return;
+  if (entry !== undefined) {
+    const idx = arr.indexOf(entry);
+    if (idx === -1) return;
+    arr.splice(idx, 1);
+  } else {
+    arr.pop();
+  }
+  if (arr.length === 0) entries.delete(key);
+  notify(key);
+}
+
+/**
+ * Fire registry subscribers for a key WITHOUT touching the entry stack. Used
+ * by useFormDraft to signal "snapshot-relevant state changed" (e.g.,
+ * lastSavedAt updated) without the unregister→register churn that previously
+ * caused useFormDraftStatus to flicker through DEFAULT_SNAPSHOT.
+ */
+export function notifySubscribers(key: string): void {
+  notify(key);
 }
 
 export function subscribeRegistry(key: string, listener: () => void): () => void {
   if (!subscribers.has(key)) subscribers.set(key, new Set());
   subscribers.get(key)!.add(listener);
   return () => {
-    subscribers.get(key)?.delete(listener);
+    const set = subscribers.get(key);
+    if (!set) return;
+    set.delete(listener);
+    if (set.size === 0) subscribers.delete(key);
   };
 }
 
diff --git a/src/useFormDraft.ts b/src/useFormDraft.ts
index c0a23f0..7dfc64f 100644
--- a/src/useFormDraft.ts
+++ b/src/useFormDraft.ts
@@ -9,7 +9,7 @@ import { createStatusMachine } from './internal/statusMachine';
 import { createSyncQueue } from './internal/syncQueue';
 import { createBroadcaster } from './internal/broadcaster';
 import { validateOrDiscard } from './internal/schemaValidation';
-import { registerDraft, unregisterDraft } from './internal/registry';
+import { notifySubscribers, registerDraft, unregisterDraft } from './internal/registry';
 import { localStorageAdapter } from './storage/localStorage';
 
 const DEFAULT_RETRY: RetryConfig = {
@@ -72,11 +72,12 @@ export function useFormDraft<T extends Record<string, unknown>>(
   const statusMachineRef = useRef(createStatusMachine());
   const [, forceStatus] = useState(0);
 
-  // Keep a ref to the current values so callbacks can read latest without stale closure
+  // Keep a ref to the current values so callbacks can read latest without
+  // stale closure. Updated during render (not in useEffect) so external
+  // imperative callers via `getFormDraft` see committed values immediately,
+  // matching the other snapshot refs below.
   const valuesRef = useRef<T>(values);
-  useEffect(() => {
-    valuesRef.current = values;
-  }, [values]);
+  valuesRef.current = values;
 
   // Refs holding the latest options so the once-created debounced functions can
   // read current values without re-running `useRef(debounce(...))` each render.
@@ -88,6 +89,10 @@ export function useFormDraft<T extends Record<string, unknown>>(
   keyRef.current = key;
   const versionRef = useRef(version);
   versionRef.current = version;
+  // Hoisted from below — also used by the restore effect's migrate path,
+  // which would otherwise read this ref before its declaration line.
+  const excludeFieldsRef = useRef(excludeFields);
+  excludeFieldsRef.current = excludeFields;
 
   // Tracks whether user has called set()/patch() since mount. Used to skip a
   // late-arriving storage restore so user input isn't clobbered.
@@ -383,8 +388,8 @@ export function useFormDraft<T extends Record<string, unknown>>(
   // Created once with stable identity; closures read from refs above so they
   // always see the latest storage/key/version/excludeFields without recreating
   // (which would lose pending timers and stale-close on old values).
-  const excludeFieldsRef = useRef(excludeFields);
-  excludeFieldsRef.current = excludeFields;
+  // excludeFieldsRef is hoisted above (near storageRef) — it's also read by
+  // the restore effect's migrate path.
 
   const persistDebouncedRef = useRef(
     debounce(async (next: T) => {
@@ -438,13 +443,64 @@ export function useFormDraft<T extends Record<string, unknown>>(
   }, [disabled, values, pendingChanges]);
 
   // --- Registry registration ---
+  // Holds the imperative action callbacks and live state snapshots so
+  // `useFormDraftStatus` (subscribes by key) and `getFormDraft` (imperative
+  // external control by key) can reach this instance without prop-drilling.
+  // Refs are mutated on every render below so external callers always see
+  // the latest closure / state values without us re-registering on each
+  // state change (which would notify subscribers far more than needed).
+  const saveRef = useRef<() => Promise<void>>(() => Promise.resolve());
+  const discardRef = useRef<() => void>(() => {});
+  const submitRef = useRef<
+    <R>(
+      handler: (v: T) => Promise<R>,
+    ) => (e?: { preventDefault?: () => void }) => Promise<R | undefined>
+  >(
+    () => async () => undefined,
+  );
+  const pendingChangesRef = useRef(pendingChanges);
+  pendingChangesRef.current = pendingChanges;
+  const errorRef = useRef(error);
+  errorRef.current = error;
+  const lastSavedAtRef = useRef(lastSavedAt);
+  lastSavedAtRef.current = lastSavedAt;
+
+  // Register ONCE per mount (no `lastSavedAt` in deps). useFormDraftStatus
+  // and getFormDraft read live values via the refs we hold here, so we don't
+  // need the unregister→register churn that previously flickered subscribers
+  // through DEFAULT_SNAPSHOT on every successful sync.
+  //
+  // Also route status-machine transitions through the registry's notify
+  // channel. Subscribers that bound directly to this entry's statusMachine
+  // would otherwise miss transitions on the actively-registered entry after
+  // a duplicate-key remount (subscribe captures the entry-at-subscribe-time
+  // and never re-binds).
   useEffect(() => {
     const entry = {
       statusMachine: statusMachineRef.current,
-      lastSavedAt,
+      saveRef,
+      discardRef,
+      submitRef,
+      valuesRef,
+      pendingChangesRef,
+      errorRef,
+      lastSavedAtRef,
     };
     registerDraft(key, entry);
-    return () => unregisterDraft(key);
+    const unsubStatus = statusMachineRef.current.subscribe(() => {
+      notifySubscribers(key);
+    });
+    return () => {
+      unsubStatus();
+      unregisterDraft(key, entry);
+    };
+  }, [key]);
+
+  // Notify registry subscribers when state worth re-snapshotting changes
+  // (just lastSavedAt for now — status changes are notified via the status
+  // machine's own subscribe channel).
+  useEffect(() => {
+    notifySubscribers(key);
   }, [key, lastSavedAt]);
 
   // Track mount status. Re-set to true on each mount so React.StrictMode's
@@ -560,6 +616,15 @@ export function useFormDraft<T extends Record<string, unknown>>(
     [onConflictData],
   );
 
+  // Sync action callbacks into refs each render so registry entries (used by
+  // getFormDraft) always invoke the LATEST closure even when discard/submit
+  // recreate due to defaultValues/key/storage changes.
+  saveRef.current = save;
+  discardRef.current = discard;
+  // submit is generic in R; coerce at the ref boundary — the registry only
+  // needs the imperative shape, not per-call return-type fidelity.
+  submitRef.current = submit as typeof submitRef.current;
+
   return {
     values,
     set,
diff --git a/src/useFormDraftStatus.ts b/src/useFormDraftStatus.ts
index 3628aba..c69a6b9 100644
--- a/src/useFormDraftStatus.ts
+++ b/src/useFormDraftStatus.ts
@@ -18,13 +18,12 @@ export function useFormDraftStatus(key: string): Snapshot {
 
   const subscribe = useCallback(
     (cb: () => void) => {
-      const unsubRegistry = subscribeRegistry(key, cb);
-      const entry = getDraft(key);
-      const unsubMachine = entry?.statusMachine.subscribe(cb) ?? (() => {});
-      return () => {
-        unsubRegistry();
-        unsubMachine();
-      };
+      // Single channel: the host useFormDraft routes its statusMachine
+      // transitions through notifySubscribers(key), so we don't need to
+      // separately subscribe to entry.statusMachine here (which would
+      // capture the entry-at-subscribe-time and miss later registrations
+      // when two instances share a key).
+      return subscribeRegistry(key, cb);
     },
     [key],
   );
@@ -38,7 +37,10 @@ export function useFormDraftStatus(key: string): Snapshot {
       return DEFAULT_SNAPSHOT;
     }
     const status = entry.statusMachine.getStatus();
-    const lastSavedMs = entry.lastSavedAt?.getTime() ?? null;
+    // Read via ref (always current). The entry's snapshot field used to be
+    // here, but that required unregister→register on every save and flickered
+    // subscribers through DEFAULT_SNAPSHOT.
+    const lastSavedMs = entry.lastSavedAtRef.current?.getTime() ?? null;
     const c = cacheRef.current;
     if (c.status === status && c.lastSavedMs === lastSavedMs) return c.snapshot;
     const snapshot: Snapshot = {