@@ -100,12 +100,19 @@ browsers revalidate with this service; that does not imply a GitHub request whil
 the relevant snapshot remains fresh.
 
 The browser runtime keeps the last counter snapshot and the last confirmed viewer
-vote state in local storage for up to seven days. Consumers can render them
+vote/star state in local storage for up to seven days. Consumers can render them
 synchronously while the API request is in flight, avoiding a flash of zero counters
 or unselected vote buttons. Snapshots contain only the site/resource key, discussion
-node ID, counts, viewer state, and save time; authentication tokens are not part of
+node ID, counts, viewer state, star state, and save time; authentication tokens are not part of
 this cache. Storage is optional and failures fall back to the network normally.
 
+Once authenticated, the runtime also resolves the current user's vote and star
+state for all visible discussions in one batched GitHub query. That viewer-specific
+snapshot is reused for five minutes, including across reloads, and then refreshed
+on demand. This makes reactions created on GitHub or another device visible without
+turning every counter request into an authenticated GitHub request. Stars map to
+GitHub's `EYES` reaction because Discussions does not provide a star reaction.
+
 Operational logs are emitted at GitHub boundaries rather than for every HTTP
 request. Reaction-refresh lines include the site, trigger (`requested` or
 `sweep`), batch size, updated-row count, and duration. Failures include safe
 
@@ -10,8 +10,16 @@ interface CounterState {
   stale: boolean;
 }
 
+type StoredReactionState = CounterState & {
+  viewer: ViewerVote;
+  viewerKnown?: boolean;
+  starred?: boolean;
+};
+
 export interface ReactionState extends CounterState {
   viewer: ViewerVote;
+  viewerKnown: boolean;
+  starred: boolean;
 }
 
 interface ReactionEnvelope {
@@ -42,6 +50,7 @@ export interface AccessToken {
   value: string;
   expiresAt: number;
   creationGrant: string;
+  viewerId?: string;
 }
 
 export interface EnsuredDiscussion {
@@ -91,13 +100,57 @@ export class FeedbackClient {
     for (const key of normalized) {
       const state = payload.items[key] ?? emptyState();
       if (!isCounterState(state)) throw new TypeError("Invalid feedback service response");
-      const combined = { ...state, viewer: this.#cachedReaction(key)?.viewer ?? "none" };
+      const cached = this.#cachedReaction(key);
+      const combined = {
+        ...state,
+        viewer: cached?.viewer ?? "none",
+        viewerKnown: cached?.viewerKnown ?? false,
+        starred: cached?.starred ?? false,
+      };
       result.set(key, combined);
       this.#storeReaction(key, combined);
     }
     return result;
   }
 
+  async syncViewerReactions(
+    keys: Iterable<string>,
+    token: AccessToken,
+    signal?: AbortSignal,
+  ): Promise<ReadonlyMap<string, ReactionState>> {
+    const normalized = [...new Set(Array.from(keys, validateResourceId))].sort();
+    if (normalized.length === 0) throw new TypeError("At least one resource key is required");
+    const pending = normalized.filter((key) => this.#viewerNeedsSync(key, token.viewerId));
+    if (pending.length > 0) {
+      const url = new URL(`/v1/sites/${encodeURIComponent(this.#site)}/viewer-reactions`, this.#apiOrigin);
+      url.searchParams.set("keys", pending.join(","));
+      const headers = { Accept: "application/json", Authorization: `Bearer ${token.value}` };
+      const init: RequestInit = { headers };
+      if (signal) init.signal = signal;
+      const response = await this.#fetch(url, init);
+      if (!response.ok) throw new FeedbackError(response.status, await errorCode(response));
+      const payload: unknown = await response.json();
+      if (!isViewerEnvelope(payload, this.#site, pending)) {
+        throw new TypeError("Invalid feedback service response");
+      }
+      for (const key of pending) {
+        const cached = this.#cachedReaction(key) ?? emptyState();
+        this.#storeReaction(
+          key,
+          {
+            ...cached,
+            viewer: payload.items[key]?.vote ?? "none",
+            starred: payload.items[key]?.starred ?? false,
+            viewerKnown: true,
+          },
+          true,
+          token.viewerId,
+        );
+      }
+    }
+    return this.cachedReactions(normalized);
+  }
+
   async authorize(challenge: string, nonce: string, signal?: AbortSignal): Promise<Authorization> {
     const payload = await this.#post("oauth/authorize", { challenge, nonce }, signal);
     const url = payload.authorization_url;
@@ -174,10 +227,26 @@ export class FeedbackClient {
       age: 0,
       stale: true,
       viewer: result.viewer,
-    });
+      viewerKnown: true,
+      starred: cached?.starred ?? false,
+    }, true, token.viewerId);
     return result;
   }
 
+  async toggleStar(key: string, token: AccessToken, signal?: AbortSignal): Promise<boolean> {
+    validateResourceId(key);
+    const payload = await this.#post("stars", { key }, signal, token.value);
+    if (typeof payload.starred !== "boolean") throw new TypeError("Invalid star response");
+    const cached = this.#cachedReaction(key) ?? emptyState();
+    this.#storeReaction(
+      key,
+      { ...cached, starred: payload.starred, viewerKnown: true },
+      true,
+      token.viewerId,
+    );
+    return payload.starred;
+  }
+
   async #post(
     path: string,
     body: Record<string, unknown>,
@@ -214,28 +283,73 @@ export class FeedbackClient {
       if (
         !Number.isSafeInteger(value.savedAt) ||
         Date.now() - (value.savedAt as number) > 7 * 24 * 60 * 60 * 1000 ||
-        !isReactionState(value.state)
+        !isStoredReactionState(value.state)
       ) {
         this.#counterStorage.removeItem(counterKey(this.#site, key));
         return null;
       }
       const elapsed = Math.max(0, Math.floor((Date.now() - (value.savedAt as number)) / 1000));
-      return { ...value.state, age: value.state.age + elapsed, stale: true };
+      return {
+        ...value.state,
+        viewerKnown: value.state.viewerKnown ?? false,
+        starred: value.state.starred ?? false,
+        age: value.state.age + elapsed,
+        stale: true,
+      };
     } catch {
       return null;
     }
   }
 
-  #storeReaction(key: string, state: ReactionState): void {
+  #storeReaction(
+    key: string,
+    state: ReactionState,
+    viewerConfirmed = false,
+    viewerId?: string,
+  ): void {
     try {
+      let viewerCheckedAt: number | null = null;
+      let existingViewerId: string | undefined;
+      const existing = this.#counterStorage?.getItem(counterKey(this.#site, key));
+      if (existing !== null && existing !== undefined) {
+        const parsed = JSON.parse(existing) as { viewerCheckedAt?: unknown; viewerId?: unknown };
+        if (Number.isSafeInteger(parsed.viewerCheckedAt)) viewerCheckedAt = parsed.viewerCheckedAt as number;
+        if (typeof parsed.viewerId === "string") existingViewerId = parsed.viewerId;
+      }
       this.#counterStorage?.setItem(
         counterKey(this.#site, key),
-        JSON.stringify({ savedAt: Date.now(), state }),
+        JSON.stringify({
+          savedAt: Date.now(),
+          viewerCheckedAt: viewerConfirmed ? Date.now() : viewerCheckedAt,
+          viewerId: viewerConfirmed ? viewerId : existingViewerId,
+          state,
+        }),
       );
     } catch {
       // Storage may be disabled or full; counters still work from the network.
     }
   }
+
+
+  #viewerNeedsSync(key: string, viewerId?: string): boolean {
+    if (this.#counterStorage === undefined) return true;
+    try {
+      const raw = this.#counterStorage.getItem(counterKey(this.#site, key));
+      if (raw === null) return true;
+      const value = JSON.parse(raw) as {
+        viewerCheckedAt?: unknown;
+        viewerId?: unknown;
+        state?: unknown;
+      };
+      return !isStoredReactionState(value.state) ||
+        !value.state.viewerKnown ||
+        (viewerId !== undefined && value.viewerId !== viewerId) ||
+        !Number.isSafeInteger(value.viewerCheckedAt) ||
+        Date.now() - (value.viewerCheckedAt as number) >= 5 * 60 * 1000;
+    } catch {
+      return true;
+    }
+  }
 }
 
 export class FeedbackError extends Error {
@@ -245,7 +359,16 @@ export class FeedbackError extends Error {
 }
 
 function emptyState(): ReactionState {
-  return { id: null, up: 0, down: 0, age: 0, stale: false, viewer: "none" };
+  return {
+    id: null,
+    up: 0,
+    down: 0,
+    age: 0,
+    stale: false,
+    viewer: "none",
+    viewerKnown: false,
+    starred: false,
+  };
 }
 
 function isEnvelope(value: unknown, site: string): value is ReactionEnvelope {
@@ -266,14 +389,42 @@ function isCounterState(value: unknown): value is CounterState {
   );
 }
 
-function isReactionState(value: unknown): value is ReactionState {
-  return isCounterState(value) && isViewerVote((value as Partial<ReactionState>).viewer);
+function isStoredReactionState(value: unknown): value is StoredReactionState {
+  return isCounterState(value) &&
+    isViewerVote((value as Partial<ReactionState>).viewer) &&
+    ((value as Partial<ReactionState>).viewerKnown === undefined ||
+      typeof (value as Partial<ReactionState>).viewerKnown === "boolean") &&
+    ((value as Partial<ReactionState>).starred === undefined ||
+      typeof (value as Partial<ReactionState>).starred === "boolean");
 }
 
 function isViewerVote(value: unknown): value is ViewerVote {
   return value === "up" || value === "down" || value === "both" || value === "none";
 }
 
+function isViewerEnvelope(
+  value: unknown,
+  site: string,
+  keys: readonly string[],
+): value is {
+  v: 1;
+  site: string;
+  items: Record<string, { vote: ViewerVote; starred: boolean }>;
+} {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as { v?: unknown; site?: unknown; items?: unknown };
+  if (candidate.v !== 1 || candidate.site !== site || !candidate.items || typeof candidate.items !== "object") {
+    return false;
+  }
+  const items = candidate.items as Record<string, unknown>;
+  return Object.keys(items).length === keys.length && keys.every((key) => {
+    const item = items[key];
+    return !!item && typeof item === "object" &&
+      isViewerVote((item as { vote?: unknown }).vote) &&
+      typeof (item as { starred?: unknown }).starred === "boolean";
+  });
+}
+
 function counterKey(site: string, resource: string): string {
   return `cppsocial.feedback.v1.${site}.reaction.${resource}`;
 }
 
@@ -96,9 +96,10 @@ export class Authentication {
         signal,
       );
       const token = await this.#service.exchange(code, authorization.state, verifier, signal);
-      await validateViewer(this.#fetch, token.value, signal);
-      this.#tokens.set(token);
-      return token;
+      const viewerId = await validateViewer(this.#fetch, token.value, signal);
+      const authenticated = { ...token, viewerId };
+      this.#tokens.set(authenticated);
+      return authenticated;
     } catch (error) {
       this.#tokens.clear();
       throw error;
@@ -171,7 +172,7 @@ async function validateViewer(
   fetch: typeof globalThis.fetch,
   token: string,
   signal?: AbortSignal,
-): Promise<void> {
+): Promise<string> {
   const init: RequestInit = {
     method: "POST",
     headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
@@ -181,17 +182,21 @@ async function validateViewer(
   const response = await fetch("https://api.github.com/graphql", init);
   if (!response.ok) throw new AuthenticationError("token_invalid");
   const body: unknown = await response.json();
-  if (!hasViewer(body)) throw new AuthenticationError("token_invalid");
+  const viewerId = viewer(body);
+  if (viewerId === null) throw new AuthenticationError("token_invalid");
+  return viewerId;
 }
 
-function hasViewer(value: unknown): boolean {
-  if (!value || typeof value !== "object") return false;
+function viewer(value: unknown): string | null {
+  if (!value || typeof value !== "object") return null;
   const data = (value as { data?: unknown }).data;
-  if (!data || typeof data !== "object") return false;
+  if (!data || typeof data !== "object") return null;
   const viewer = (data as { viewer?: unknown }).viewer;
-  if (!viewer || typeof viewer !== "object") return false;
+  if (!viewer || typeof viewer !== "object") return null;
   const candidate = viewer as { id?: unknown; login?: unknown };
-  return typeof candidate.id === "string" && typeof candidate.login === "string";
+  return typeof candidate.id === "string" && typeof candidate.login === "string"
+    ? candidate.id
+    : null;
 }
 
 function randomBase64Url(crypto: Crypto, size: number): string {
 
@@ -6,6 +6,7 @@ interface StoredToken {
   value: string;
   expiresAt: number;
   creationGrant: string;
+  viewerId: string;
 }
 
 export class SessionTokenStore {
@@ -29,6 +30,8 @@ export class SessionTokenStore {
         !parsed.value.startsWith("ghu_") ||
         !Number.isSafeInteger(parsed.expiresAt) ||
         typeof parsed.creationGrant !== "string" ||
+        typeof parsed.viewerId !== "string" ||
+        parsed.viewerId.length === 0 ||
         (parsed.expiresAt ?? 0) * 1000 <= this.#clock()
       ) {
         this.clear();
@@ -38,6 +41,7 @@ export class SessionTokenStore {
         value: parsed.value,
         expiresAt: parsed.expiresAt,
         creationGrant: parsed.creationGrant,
+        viewerId: parsed.viewerId,
       } as AccessToken;
     } catch {
       this.clear();