diff --git a/apps/dashboard/package.json b/apps/dashboard/package.json
index 564015e65..adca555c6 100644
--- a/apps/dashboard/package.json
+++ b/apps/dashboard/package.json
@@ -13,6 +13,7 @@
   },
   "prettier": "@sanity/prettier-config",
   "dependencies": {
+    "@sanity/sdk": "workspace:*",
     "@sanity/sdk-react": "workspace:*",
     "@sanity/ui": "^2.15.13",
     "react": "^18.3.1",
diff --git a/apps/dashboard/src/App.tsx b/apps/dashboard/src/App.tsx
index 18efa4eb9..24eb46949 100644
--- a/apps/dashboard/src/App.tsx
+++ b/apps/dashboard/src/App.tsx
@@ -1,7 +1,8 @@
+import {createSubscriptionRequest, registerSubscription, unregisterSubscription} from '@sanity/sdk'
 import {SanityApp, SanityConfig} from '@sanity/sdk-react'
 import {Spinner, ThemeProvider} from '@sanity/ui'
 import {buildTheme} from '@sanity/ui/theme'
-import {type JSX, Suspense} from 'react'
+import {type JSX, Suspense, useState} from 'react'
 
 const theme = buildTheme({})
 
@@ -20,6 +21,78 @@ const devConfigs: SanityConfig[] = [
   },
 ]
 
+// SharedWorker test component
+function SharedWorkerTest() {
+  const [subscriptionId, setSubscriptionId] = useState<string | null>(null)
+  const [status, setStatus] = useState<string>('Ready to test')
+
+  const testSubscription = async () => {
+    // eslint-disable-next-line no-console
+    console.log('testSubscription')
+    try {
+      setStatus('Testing subscription...')
+
+      const subscription = createSubscriptionRequest({
+        storeName: 'query',
+        projectId: 'ppsg7ml5',
+        dataset: 'test',
+        params: {
+          query: '*[_type == "movie"]',
+          options: {},
+        },
+        appId: 'dashboard-app',
+      })
+
+      const id = await registerSubscription(subscription)
+      setSubscriptionId(id)
+      setStatus(`Subscription registered: ${id}`)
+    } catch (error) {
+      setStatus(`Error: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  const testUnsubscription = async () => {
+    if (!subscriptionId) return
+
+    try {
+      setStatus('Testing unsubscription...')
+
+      await unregisterSubscription(subscriptionId)
+      setSubscriptionId(null)
+      setStatus('Subscription unregistered successfully')
+    } catch (error) {
+      setStatus(`Error: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
+  return (
+    <div style={{padding: 12, borderBottom: '1px solid #eee'}}>
+      <div>Dashboard (iframes sdk-app below)</div>
+      <div style={{marginTop: 8, fontSize: '14px'}}>
+        <div>SharedWorker Test:</div>
+        <div style={{marginTop: 4}}>
+          <button onClick={testSubscription} disabled={!!subscriptionId}>
+            Test Subscription
+          </button>
+          {subscriptionId && (
+            <button onClick={testUnsubscription} style={{marginLeft: 8}}>
+              Test Unsubscription
+            </button>
+          )}
+        </div>
+        <div style={{marginTop: 4, fontFamily: 'monospace', fontSize: '12px'}}>
+          Status: {status}
+        </div>
+        {subscriptionId && (
+          <div style={{marginTop: 4, fontFamily: 'monospace', fontSize: '12px'}}>
+            Active Subscription: {subscriptionId}
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
 export default function App(): JSX.Element {
   return (
     <ThemeProvider theme={theme}>
@@ -33,9 +106,7 @@ export default function App(): JSX.Element {
               flexDirection: 'column',
             }}
           >
-            <div style={{padding: 12, borderBottom: '1px solid #eee'}}>
-              Dashboard (iframes sdk-app below)
-            </div>
+            <SharedWorkerTest />
             <iframe
               title="sdk-app"
               src="http://localhost:3341/"
diff --git a/apps/dashboard/src/main.tsx b/apps/dashboard/src/main.tsx
index 00710ad43..fde7d039d 100644
--- a/apps/dashboard/src/main.tsx
+++ b/apps/dashboard/src/main.tsx
@@ -1,8 +1,33 @@
+import {addStatusListener, getSdkWorker, type WorkerStatus} from '@sanity/sdk'
+import sdkWorker from '@sanity/sdk/worker?worker&url'
 import {StrictMode} from 'react'
 import {createRoot} from 'react-dom/client'
 
 import App from './App'
 
+// Initialize SharedWorker for subscription management
+async function initializeSharedWorker() {
+  try {
+    // Get the SDK worker instance - use direct URL
+    const workerUrl = new URL(sdkWorker, import.meta.url).href
+
+    getSdkWorker(workerUrl)
+
+    // Add status listener for debugging
+    addStatusListener((status: WorkerStatus) => {
+      // eslint-disable-next-line no-console
+      console.log('[Dashboard] Worker status changed:', status)
+    })
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.warn('Failed to initialize SharedWorker:', error)
+    // Fallback to local subscription management
+  }
+}
+
+// Initialize SharedWorker when the app starts
+initializeSharedWorker()
+
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
     <App />
diff --git a/knip.config.ts b/knip.config.ts
index 60a67da7f..7868c36fa 100644
--- a/knip.config.ts
+++ b/knip.config.ts
@@ -87,7 +87,7 @@ const baseConfig = {
       },
       project,
       entry: ['package.bundle.ts'],
-      ignore: ['src/presence/bifurTransport.ts', 'src/presence/types.ts'],
+      ignore: ['src/presence/bifurTransport.ts', 'src/presence/types.ts', 'src/_exports/worker.ts'],
       ignoreDependencies: ['@sanity/bifur-client', '@sanity/browserslist-config'],
     },
   },
diff --git a/packages/core/src/_exports/index.ts b/packages/core/src/_exports/index.ts
index d052c8e2a..26068646b 100644
--- a/packages/core/src/_exports/index.ts
+++ b/packages/core/src/_exports/index.ts
@@ -132,6 +132,28 @@ export {
 export {getPerspectiveState} from '../releases/getPerspectiveState'
 export type {ReleaseDocument} from '../releases/releasesStore'
 export {getActiveReleasesState} from '../releases/releasesStore'
+export {
+  addStatusListener,
+  disconnectWorker,
+  getSdkWorker,
+  registerSubscription,
+  sendMessage,
+  unregisterSubscription,
+  type WorkerStatus,
+} from '../sharedWorkerStore/sharedWorkerClient'
+export {type SharedWorkerStore, sharedWorkerStore} from '../sharedWorkerStore/sharedWorkerStore'
+export {
+  type ActiveSubscription,
+  type SharedWorkerStoreActions,
+  type SharedWorkerStoreState,
+  type SubscriptionRequest,
+} from '../sharedWorkerStore/types'
+export {
+  areSubscriptionsEquivalent,
+  createSubscriptionId,
+  createSubscriptionRequest,
+  groupSubscriptionsByParams,
+} from '../sharedWorkerStore/utils/subscriptionManager'
 export {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 export {type Selector, type StateSource} from '../store/createStateSourceAction'
 export {getUsersKey, parseUsersKey} from '../users/reducers'
diff --git a/packages/core/src/_exports/worker.ts b/packages/core/src/_exports/worker.ts
new file mode 100644
index 000000000..3b169c882
--- /dev/null
+++ b/packages/core/src/_exports/worker.ts
@@ -0,0 +1,158 @@
+/// <reference lib="webworker" />
+/* eslint-disable no-console */
+
+/**
+ * @internal
+ * SharedWorker for managing subscriptions across SDK apps
+ */
+
+import {sharedWorkerStore} from '../sharedWorkerStore/sharedWorkerStore'
+import {type SubscriptionRequest} from '../sharedWorkerStore/types'
+
+declare const self: SharedWorkerGlobalScope
+
+console.log('[SharedWorker] Worker script loaded')
+
+// Handle new connections
+self.onconnect = (event: MessageEvent) => {
+  const port = event.ports[0]
+
+  console.log('[SharedWorker] New connection established')
+
+  // Set up message handling for this port
+  port.onmessage = async (e: MessageEvent) => {
+    const {type, data} = e.data
+
+    console.log('[SharedWorker] Received message:', type, data)
+
+    try {
+      switch (type) {
+        case 'REGISTER_SUBSCRIPTION':
+          handleRegisterSubscription(data, port)
+          break
+        case 'UNREGISTER_SUBSCRIPTION':
+          handleUnregisterSubscription(data.subscriptionId, port)
+          break
+        case 'GET_SUBSCRIPTION_COUNT':
+          handleGetSubscriptionCount(port)
+          break
+        case 'GET_ALL_SUBSCRIPTIONS':
+          handleGetAllSubscriptions(port)
+          break
+        default:
+          console.warn('[SharedWorker] Unknown message type:', type)
+          port.postMessage({
+            type: 'ERROR',
+            data: {error: `Unknown message type: ${type}`},
+          })
+      }
+    } catch (error) {
+      console.error('[SharedWorker] Error handling message:', error)
+      port.postMessage({
+        type: 'ERROR',
+        data: {error: (error as Error).message},
+      })
+    }
+  }
+
+  // Start the port
+  port.start()
+  console.log('[SharedWorker] Port started, sending welcome message')
+  port.postMessage({type: 'welcome'})
+}
+
+/**
+ * @internal
+ * Handle the registration of a subscription
+ * @param subscription - The subscription to register
+ * @param port - The port to send the response to
+ */
+function handleRegisterSubscription(subscription: SubscriptionRequest, port: MessagePort): void {
+  try {
+    sharedWorkerStore.getState().registerSubscription(subscription)
+
+    // Send confirmation back to the client
+    port.postMessage({
+      type: 'SUBSCRIPTION_REGISTERED',
+      data: {subscriptionId: subscription.subscriptionId},
+    })
+
+    console.log('[SharedWorker] Registered subscription:', subscription.subscriptionId)
+  } catch (error) {
+    console.error('[SharedWorker] Failed to register subscription:', error)
+
+    // Send error back to the client
+    port.postMessage({
+      type: 'SUBSCRIPTION_ERROR',
+      data: {error: (error as Error).message, subscriptionId: subscription.subscriptionId},
+    })
+  }
+}
+
+/**
+ * @internal
+ * Handle the unregistration of a subscription
+ * @param subscriptionId - The ID of the subscription to unregister
+ * @param port - The port to send the response to
+ */
+function handleUnregisterSubscription(subscriptionId: string, port: MessagePort): void {
+  try {
+    sharedWorkerStore.getState().unregisterSubscription(subscriptionId)
+
+    // Send confirmation back to the client
+    port.postMessage({
+      type: 'SUBSCRIPTION_UNREGISTERED',
+      data: {subscriptionId},
+    })
+
+    console.log('[SharedWorker] Unregistered subscription:', subscriptionId)
+  } catch (error) {
+    console.error('[SharedWorker] Failed to unregister subscription:', error)
+
+    // Send error back to the client
+    port.postMessage({
+      type: 'SUBSCRIPTION_ERROR',
+      data: {error: (error as Error).message, subscriptionId},
+    })
+  }
+}
+
+function handleGetSubscriptionCount(port: MessagePort): void {
+  try {
+    const count = sharedWorkerStore.getState().getSubscriptionCount()
+
+    port.postMessage({
+      type: 'SUBSCRIPTION_COUNT',
+      data: {count},
+    })
+  } catch (error) {
+    console.error('[SharedWorker] Failed to get subscription count:', error)
+
+    port.postMessage({
+      type: 'SUBSCRIPTION_ERROR',
+      data: {error: (error as Error).message},
+    })
+  }
+}
+
+function handleGetAllSubscriptions(port: MessagePort): void {
+  try {
+    const subscriptions = sharedWorkerStore.getState().getAllSubscriptions()
+
+    port.postMessage({
+      type: 'ALL_SUBSCRIPTIONS',
+      data: {subscriptions},
+    })
+  } catch (error) {
+    console.error('[SharedWorker] Failed to get all subscriptions:', error)
+
+    port.postMessage({
+      type: 'SUBSCRIPTION_ERROR',
+      data: {error: (error as Error).message},
+    })
+  }
+}
+
+// Export for testing/development (this won't be used in the actual SharedWorker)
+/** @internal */
+export {handleRegisterSubscription, handleUnregisterSubscription}
diff --git a/packages/core/src/sharedWorkerStore/README.md b/packages/core/src/sharedWorkerStore/README.md
new file mode 100644
index 000000000..98cec721d
--- /dev/null
+++ b/packages/core/src/sharedWorkerStore/README.md
@@ -0,0 +1,120 @@
+# SharedWorker Store
+
+> **@internal** - This is an internal implementation for the SharedWorker integration POC.
+
+## Overview
+
+The SharedWorker store provides a centralized subscription management system for SDK apps running within the Dashboard iframe environment. It acts as a "meta-store" that tracks active subscriptions across multiple apps and can coordinate data updates.
+
+## Architecture
+
+### Core Components
+
+- **`sharedWorkerStore`**: Zustand-based store that manages subscription state
+- **`SubscriptionRequest`**: Interface for subscription registration requests
+- **`ActiveSubscription`**: Represents an active subscription with metadata
+- **Utility functions**: Helper functions for subscription management
+
+### State Structure
+
+The store maintains a single data structure:
+
+1. **`subscriptions`**: Map of subscription ID to subscription details
+
+### Key Features
+
+- **Subscription Registration**: Add new subscriptions with metadata
+- **Subscription Cleanup**: Remove subscriptions when apps disconnect
+- **Simple Lookups**: Fast subscription queries by ID
+- **Duplicate Detection**: Utilities to identify equivalent subscriptions
+
+## Usage
+
+### Basic Subscription Management
+
+```typescript
+import {sharedWorkerStore, createSubscriptionRequest} from '@sanity/sdk'
+
+// Register a query subscription
+const subscription = createSubscriptionRequest({
+  storeName: 'query',
+  projectId: 'my-project',
+  dataset: 'production',
+  params: ['*[_type == "movie"]', {}],
+})
+
+sharedWorkerStore.getState().registerSubscription(subscription)
+
+// Later, unregister
+sharedWorkerStore.getState().unregisterSubscription(subscription.subscriptionId)
+```
+
+### Querying Subscriptions
+
+```typescript
+// Get all active subscriptions
+const allSubs = sharedWorkerStore.getState().getAllSubscriptions()
+
+// Check if a subscription exists
+const exists = sharedWorkerStore.getState().hasSubscription(subscriptionId)
+
+// Get total count
+const count = sharedWorkerStore.getState().getSubscriptionCount()
+```
+
+### Utility Functions
+
+```typescript
+import {
+  areSubscriptionsEquivalent,
+  groupSubscriptionsByParams,
+  findDuplicateSubscriptions,
+} from '@sanity/sdk'
+
+// Check if two subscriptions are equivalent
+const equivalent = areSubscriptionsEquivalent(sub1, sub2)
+
+// Group subscriptions by their parameters
+const groups = groupSubscriptionsByParams(subscriptions)
+
+// Find duplicate subscriptions that could be consolidated
+const duplicates = findDuplicateSubscriptions(subscriptions)
+```
+
+## Design Decisions
+
+### Why Zustand?
+
+- **Lightweight**: Minimal bundle size impact
+- **Familiar**: Consistent with existing store patterns in the SDK
+- **Flexible**: Easy to extend with new actions and state
+
+### Subscription Management
+
+Simple subscription tracking focused on individual subscription lifecycle:
+
+- **By ID**: Fast individual subscription access
+- **Minimal State**: Single map for all subscriptions
+- **Clean Operations**: Register, unregister, check existence
+
+### Immutable Updates
+
+All state updates create new Map/Set instances to ensure proper reactivity and avoid mutation issues.
+
+## Future Enhancements
+
+This is a POC implementation. Future versions may include:
+
+- **Data Caching**: Store actual query results in the SharedWorker
+- **Update Broadcasting**: Push data updates to subscribed apps
+- **Connection Management**: Handle app disconnections and reconnections
+- **Performance Metrics**: Track subscription patterns and optimize accordingly
+
+## Integration Points
+
+The SharedWorker store is designed to integrate with:
+
+1. **Existing SDK Stores**: Query, document, and other stores can register subscriptions
+2. **Comlink System**: Use existing cross-app communication infrastructure
+3. **Dashboard Environment**: Detect when running in Dashboard iframe context
+4. **Fallback Behavior**: Gracefully degrade when SharedWorker is unavailable
diff --git a/packages/core/src/sharedWorkerStore/sharedWorkerClient.ts b/packages/core/src/sharedWorkerStore/sharedWorkerClient.ts
new file mode 100644
index 000000000..ca9afd5af
--- /dev/null
+++ b/packages/core/src/sharedWorkerStore/sharedWorkerClient.ts
@@ -0,0 +1,270 @@
+/* eslint-disable no-console */
+/**
+ * @internal
+ * Client utility for Dashboard to register and communicate with the SharedWorker
+ */
+
+import {type SubscriptionRequest} from './types'
+
+type SendMessage = (type: string, payload: unknown) => Promise<{type: string; data: unknown}>
+
+// Worker status types
+/** @internal */
+export type WorkerStatus = 'connected' | 'disconnected' | 'connecting' | 'error'
+
+// Message buffer for when worker is not yet connected
+const messageBuffer: Array<{type: string; data: unknown; messageId: string}> = []
+
+// Worker instance and status
+let workerInstance: SharedWorker | null = null
+let workerStatus: WorkerStatus = 'disconnected'
+const messageHandlers = new Map<string, (response: {type: string; data: unknown}) => void>()
+
+// Event listeners for status changes
+const statusListeners = new Set<(status: WorkerStatus) => void>()
+
+// Function to update worker status and notify listeners
+function updateWorkerStatus(status: WorkerStatus) {
+  workerStatus = status
+  statusListeners.forEach((listener) => listener(status))
+}
+
+/**
+ * @internal
+ * Function to register status change listeners
+ */
+export function addStatusListener(listener: (status: WorkerStatus) => void): () => void {
+  statusListeners.add(listener)
+  return () => statusListeners.delete(listener)
+}
+
+/**
+ * @internal
+ * Get or create the SDK worker instance
+ */
+export function getSdkWorker(workerUrl: string): {status: WorkerStatus; sendMessage: SendMessage} {
+  console.log('[SharedWorkerClient] getSdkWorker called with URL:', workerUrl)
+
+  if (workerInstance) {
+    console.log('[SharedWorkerClient] Worker instance already exists')
+    return {
+      status: workerStatus,
+      sendMessage,
+    }
+  }
+
+  // Set status to connecting before creating the worker
+  updateWorkerStatus('connecting')
+
+  try {
+    const worker = new SharedWorker(workerUrl, {
+      type: 'module',
+    })
+    console.log('[SharedWorkerClient] SharedWorker created successfully')
+
+    workerInstance = worker
+
+    // Set up port message handling
+    worker.port.onmessage = (event) => {
+      console.log('[SharedWorkerClient] Received message from worker:', event.data)
+      const response = event.data
+
+      // Handle connection status message
+      if (response.type === 'welcome') {
+        console.log('[SharedWorkerClient] Received welcome message')
+        updateWorkerStatus('connected')
+        // Process any buffered messages
+        processBufferedMessages()
+        return
+      }
+
+      // Handle regular messages - find the handler by checking all handlers
+      for (const [messageId, handler] of messageHandlers.entries()) {
+        // Check if this response matches the expected response type for this message
+        if (isResponseForMessage(response, messageId)) {
+          handler(response)
+          messageHandlers.delete(messageId)
+          break
+        }
+      }
+    }
+
+    // Start the port
+    worker.port.start()
+
+    // Handle worker connection errors
+    worker.port.onmessageerror = (error) => {
+      console.error('[SharedWorkerClient] Port message error:', error)
+      updateWorkerStatus('error')
+    }
+
+    // Handle worker errors
+    worker.onerror = (error) => {
+      console.error('[SharedWorkerClient] Worker error:', error)
+      updateWorkerStatus('error')
+    }
+  } catch (error) {
+    console.error('[SharedWorkerClient] Failed to create worker:', error)
+    updateWorkerStatus('error')
+  }
+
+  console.log('[SharedWorkerClient] getSdkWorker returning with status:', workerStatus)
+  return {
+    status: workerStatus,
+    sendMessage,
+  }
+}
+
+// Helper function to determine if a response matches a message
+function isResponseForMessage(response: {type: string; data: unknown}, messageId: string): boolean {
+  // Extract the message type from the messageId
+  // messageId format: "REGISTER_SUBSCRIPTION_timestamp_random"
+  const parts = messageId.split('_')
+  const messageType = parts.slice(0, -2).join('_') // Remove timestamp and random parts
+
+  // A bit hard-coded. We can pass in configuration later
+  const responseMap: Record<string, string[]> = {
+    REGISTER_SUBSCRIPTION: ['SUBSCRIPTION_REGISTERED', 'SUBSCRIPTION_ERROR'],
+    UNREGISTER_SUBSCRIPTION: ['SUBSCRIPTION_UNREGISTERED', 'SUBSCRIPTION_ERROR'],
+    GET_SUBSCRIPTION_COUNT: ['SUBSCRIPTION_COUNT', 'SUBSCRIPTION_ERROR'],
+    GET_ALL_SUBSCRIPTIONS: ['ALL_SUBSCRIPTIONS', 'SUBSCRIPTION_ERROR'],
+  }
+
+  const expectedResponses = responseMap[messageType] || []
+  const result = expectedResponses.includes(response.type)
+  return result
+}
+
+// Process any buffered messages once connected
+function processBufferedMessages() {
+  if (workerStatus !== 'connected' || !workerInstance) return
+
+  while (messageBuffer.length > 0) {
+    const message = messageBuffer.shift()
+    if (message) {
+      sendMessageInternal(message)
+    }
+  }
+}
+
+// Internal function to send a message to the worker
+function sendMessageInternal(message: {type: string; data: unknown; messageId?: string}): boolean {
+  if (!workerInstance || workerStatus !== 'connected') {
+    return false
+  }
+
+  // Remove messageId from the message sent to worker
+  const {messageId: _, ...workerMessage} = message
+  workerInstance.port.postMessage(workerMessage)
+  return true
+}
+
+// Internal function to handle message sending and response
+function handleMessage(message: {
+  type: string
+  data: unknown
+}): Promise<{type: string; data: unknown}> {
+  const startTime = Date.now()
+  const messageId = `${message.type}_${Date.now()}_${Math.random().toString(36).slice(2)}`
+
+  const promise = new Promise<{type: string; data: unknown}>((resolve, reject) => {
+    messageHandlers.set(messageId, (response) => {
+      const responseTime = Date.now() - startTime
+      console.log(`[SharedWorkerClient] Message handled in ${responseTime}ms:`, message.type)
+      resolve(response)
+    })
+
+    // Set a timeout to reject the promise if no response is received
+    setTimeout(() => {
+      if (messageHandlers.has(messageId)) {
+        messageHandlers.delete(messageId)
+        reject(new Error('Message timeout'))
+      }
+    }, 30000) // 30 second timeout
+  })
+
+  // If worker is explicitly disconnected, reject immediately
+  if (workerStatus === 'disconnected') {
+    return Promise.reject(new Error('Worker explicitly disconnected'))
+  }
+
+  // If worker is in error state, reject immediately
+  if (workerStatus === 'error') {
+    return Promise.reject(new Error('Worker in error state'))
+  }
+
+  // If worker is not yet connected, buffer the message
+  if (workerStatus !== 'connected') {
+    messageBuffer.push({...message, messageId})
+    return promise
+  }
+
+  // Send message if connected
+  const sent = sendMessageInternal({...message, messageId})
+  if (!sent) {
+    return Promise.reject(new Error('Failed to send message'))
+  }
+
+  return promise
+}
+
+/**
+ * @internal
+ * Send a message to the worker
+ */
+export function sendMessage(
+  type: string,
+  payload: unknown,
+): Promise<{type: string; data: unknown}> {
+  const message = {type, data: payload}
+  return handleMessage(message)
+}
+
+/**
+ * @internal
+ * Disconnect the worker
+ */
+export function disconnectWorker(): void {
+  if (workerInstance) {
+    workerInstance.port.close()
+    workerInstance = null
+    updateWorkerStatus('disconnected')
+    messageBuffer.length = 0 // Clear message buffer
+  }
+}
+
+/**
+ * @internal
+ * Register a subscription with the SharedWorker
+ * @param subscription - Subscription to register
+ * @returns Promise that resolves when subscription is confirmed
+ */
+export async function registerSubscription(subscription: SubscriptionRequest): Promise<string> {
+  const response = await sendMessage('REGISTER_SUBSCRIPTION', subscription)
+
+  if (response.type === 'SUBSCRIPTION_REGISTERED') {
+    return (response.data as {subscriptionId: string}).subscriptionId
+  } else if (response.type === 'SUBSCRIPTION_ERROR') {
+    throw new Error((response.data as {error: string}).error)
+  } else {
+    throw new Error(`Unexpected response type: ${response.type}`)
+  }
+}
+
+/**
+ * @internal
+ * Unregister a subscription with the SharedWorker
+ * @param subscriptionId - ID of subscription to unregister
+ * @returns Promise that resolves when unregistration is confirmed
+ */
+export async function unregisterSubscription(subscriptionId: string): Promise<void> {
+  const response = await sendMessage('UNREGISTER_SUBSCRIPTION', {subscriptionId})
+
+  if (response.type === 'SUBSCRIPTION_UNREGISTERED') {
+    return
+  } else if (response.type === 'SUBSCRIPTION_ERROR') {
+    throw new Error((response.data as {error: string}).error)
+  } else {
+    throw new Error(`Unexpected response type: ${response.type}`)
+  }
+}
diff --git a/packages/core/src/sharedWorkerStore/sharedWorkerStore.ts b/packages/core/src/sharedWorkerStore/sharedWorkerStore.ts
new file mode 100644
index 000000000..0563e6409
--- /dev/null
+++ b/packages/core/src/sharedWorkerStore/sharedWorkerStore.ts
@@ -0,0 +1,71 @@
+import {createStore} from 'zustand/vanilla'
+
+import {
+  type ActiveSubscription,
+  type SharedWorkerStoreActions,
+  type SharedWorkerStoreState,
+} from './types'
+
+/**
+ * @internal
+ * ServiceWorker store that manages subscriptions across SDK apps
+ *
+ * This store acts as a central registry for all active subscriptions,
+ * allowing the ServiceWorker to track which apps are subscribed to which data
+ * and coordinate updates accordingly.
+ */
+export const sharedWorkerStore = createStore<SharedWorkerStoreState & SharedWorkerStoreActions>(
+  (set, get) => ({
+    // Initial state
+    subscriptions: new Map(),
+
+    // Actions
+    registerSubscription: (subscription) => {
+      const activeSubscription: ActiveSubscription = {
+        ...subscription,
+        isActive: true,
+        lastUpdate: Date.now(),
+      }
+
+      set((state) => {
+        const newSubscriptions = new Map(state.subscriptions)
+        newSubscriptions.set(subscription.subscriptionId, activeSubscription)
+
+        return {
+          subscriptions: newSubscriptions,
+        }
+      })
+    },
+
+    unregisterSubscription: (subscriptionId) => {
+      set((state) => {
+        const newSubscriptions = new Map(state.subscriptions)
+        newSubscriptions.delete(subscriptionId)
+
+        return {
+          subscriptions: newSubscriptions,
+        }
+      })
+    },
+
+    hasSubscription: (subscriptionId) => {
+      const state = get()
+      const subscription = state.subscriptions.get(subscriptionId)
+      return subscription !== undefined && subscription.isActive
+    },
+
+    getSubscriptionCount: () => {
+      const state = get()
+      return Array.from(state.subscriptions.values()).filter((sub) => sub.isActive).length
+    },
+
+    getAllSubscriptions: () => {
+      const state = get()
+      return Array.from(state.subscriptions.values()).filter((sub) => sub.isActive)
+    },
+  }),
+)
+
+// Type assertion to ensure the store has the correct shape
+/** @internal */
+export type SharedWorkerStore = typeof sharedWorkerStore
diff --git a/packages/core/src/sharedWorkerStore/types.ts b/packages/core/src/sharedWorkerStore/types.ts
new file mode 100644
index 000000000..dd5286882
--- /dev/null
+++ b/packages/core/src/sharedWorkerStore/types.ts
@@ -0,0 +1,62 @@
+/**
+ * @internal
+ * Types for the SharedWorker store that manages subscriptions across SDK apps
+ */
+
+/**
+ * @internal
+ * Represents a subscription request from an SDK app
+ */
+export interface SubscriptionRequest {
+  /** Unique identifier for this subscription */
+  subscriptionId: string
+  /** Name of the store this subscription is for (e.g., 'query', 'document') */
+  storeName: string
+  /** Project ID this subscription belongs to */
+  projectId: string
+  /** Dataset this subscription belongs to */
+  dataset: string
+  /** Store-specific parameters (e.g., query string, document ID) */
+  params?: Record<string, unknown>
+  /** Timestamp when subscription was created */
+  createdAt: number
+  /** Application ID of the subscription request */
+  appId: string
+}
+
+/**
+ * @internal
+ * Represents an active subscription in the SharedWorker
+ */
+export interface ActiveSubscription extends SubscriptionRequest {
+  /** Whether this subscription is currently active */
+  isActive: boolean
+  /** Last time this subscription received an update */
+  lastUpdate?: number
+}
+
+/**
+ * @internal
+ * State of the SharedWorker store
+ */
+export interface SharedWorkerStoreState {
+  /** Map of active subscriptions by their ID */
+  subscriptions: Map<string, ActiveSubscription>
+}
+
+/**
+ * @internal
+ * Actions that can be performed on the SharedWorker store
+ */
+export interface SharedWorkerStoreActions {
+  /** Register a new subscription */
+  registerSubscription: (subscription: SubscriptionRequest) => void
+  /** Unregister a subscription */
+  unregisterSubscription: (subscriptionId: string) => void
+  /** Check if a subscription exists */
+  hasSubscription: (subscriptionId: string) => boolean
+  /** Get total count of active subscriptions */
+  getSubscriptionCount: () => number
+  /** Get all active subscriptions */
+  getAllSubscriptions: () => ActiveSubscription[]
+}
diff --git a/packages/core/src/sharedWorkerStore/utils/subscriptionManager.ts b/packages/core/src/sharedWorkerStore/utils/subscriptionManager.ts
new file mode 100644
index 000000000..e39f01bd9
--- /dev/null
+++ b/packages/core/src/sharedWorkerStore/utils/subscriptionManager.ts
@@ -0,0 +1,81 @@
+import {type ActiveSubscription, type SubscriptionRequest} from '../types'
+
+/**
+ * @internal
+ * Utility functions for managing subscriptions in the SharedWorker store
+ */
+
+/**
+ * @internal
+ * Creates a unique subscription ID
+ * @returns A unique string identifier
+ */
+export function createSubscriptionId(): string {
+  return `sw-sub-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+}
+
+/**
+ * @internal
+ * Creates a subscription request object
+ * @param options - Configuration for the subscription
+ * @returns A properly formatted subscription request
+ */
+export function createSubscriptionRequest(options: {
+  storeName: string
+  projectId: string
+  dataset: string
+  params?: Record<string, unknown>
+  subscriptionId?: string
+  appId: string
+}): SubscriptionRequest {
+  return {
+    subscriptionId: options.subscriptionId || createSubscriptionId(),
+    storeName: options.storeName,
+    projectId: options.projectId,
+    dataset: options.dataset,
+    params: options.params || {},
+    createdAt: Date.now(),
+    appId: options.appId,
+  }
+}
+
+/**
+ * @internal
+ * Checks if two subscriptions are equivalent (same store, project, dataset, and params)
+ * @param sub1 - First subscription
+ * @param sub2 - Second subscription
+ * @returns True if subscriptions are equivalent
+ */
+export function areSubscriptionsEquivalent(
+  sub1: SubscriptionRequest,
+  sub2: SubscriptionRequest,
+): boolean {
+  return (
+    sub1.storeName === sub2.storeName &&
+    sub1.projectId === sub2.projectId &&
+    sub1.dataset === sub2.dataset &&
+    JSON.stringify(sub1.params) === JSON.stringify(sub2.params)
+  )
+}
+
+/**
+ * @internal
+ * Groups subscriptions by their parameters for efficient lookup
+ * @param subscriptions - Array of active subscriptions
+ * @returns Map of parameter hash to subscription IDs
+ */
+export function groupSubscriptionsByParams(
+  subscriptions: ActiveSubscription[],
+): Map<string, string[]> {
+  const groups = new Map<string, string[]>()
+
+  for (const subscription of subscriptions) {
+    const paramHash = JSON.stringify(subscription.params || {})
+    if (!groups.has(paramHash)) {
+      groups.set(paramHash, [])
+    }
+    groups.get(paramHash)!.push(subscription.subscriptionId)
+  }
+
+  return groups
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9c9da91b3..87b8692eb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -95,6 +95,9 @@ importers:
 
   apps/dashboard:
     dependencies:
+      '@sanity/sdk':
+        specifier: workspace:*
+        version: link:../../packages/core
       '@sanity/sdk-react':
         specifier: workspace:*
         version: link:../../packages/react