const key = cacheKey(origin);

const data = await chrome.storage.local.get(key);

return data[key] || null;

const all = await chrome.storage.local.get(null);

const entries = {};

for (const key of Object.keys(all)) {

if (key.startsWith(CACHE_PREFIX)) entries[key.slice(CACHE_PREFIX.length)] = all[key];

}

return entries;

const all = await chrome.storage.local.get(null);

const now = Date.now();

const stale = [];

for (const key of Object.keys(all)) {

if (!key.startsWith(CACHE_PREFIX)) continue;

const entry = all[key];

if (!entry || !entry.lastSeen || now - entry.lastSeen > PURGE_AFTER) stale.push(key);

}

if (stale.length) await chrome.storage.local.remove(stale);

const run = storageWriteChain.then(mutate, mutate);

// Keep the chain alive past a failed write; the caller still sees the

// rejection through `run`.

storageWriteChain = run.then(() => undefined, () => undefined);

return run;

if (!baseUrl || typeof baseUrl !== 'string') return null;

let canonical;

try {

const u = new URL(baseUrl);

if (u.protocol !== 'http:' && u.protocol !== 'https:') return null;

if (u.origin !== origin) return null;

canonical = u.origin + u.pathname.replace(/\/+$/, '');

} catch (_) {

return null;

}

if (canonical !== origin) return baseUrl; // real subdirectory path

if (evidence === 'admin-path' && typeof pathname === 'string') {

const viaAdmin = WPDetect.deriveBase(origin, null, pathname);

if (viaAdmin.evidence === 'admin-path' && viaAdmin.baseUrl === origin) return origin;

// An admin claim the attested path can't reproduce gets no shortcut —

// but the REST route below may still confirm the root on its own terms.

}

if (restApiRoot && typeof restApiRoot === 'string') {

const viaRest = WPDetect.deriveBase(origin, restApiRoot, null);

if (viaRest.evidence === 'rest' && viaRest.baseUrl === origin) return origin;

}

return null;

if (!origin) return;

await enqueueStorageWrite(async () => {

const data = await chrome.storage.local.get(WPMySites.STORE_KEY);

const orig = data[WPMySites.STORE_KEY] || {};

// Re-key a pre-#94 origin-keyed store before the upsert so keying and

// attribution see canonical install-base keys. Idempotent — a

// same-reference no-op on every store this build has written.

const store = WPMySites.migrateStore(orig);

const next = WPMySites.upsertOnLogin(store, {

origin, baseUrl: baseUrl || null, iconUrl: iconUrl || null,

now: Date.now(), pathname: pathname || null,

});

if (next !== orig) {

await chrome.storage.local.set({ [WPMySites.STORE_KEY]: next });

}

});

if (typeof key !== 'string' || !key) throw new Error('bad key');

return enqueueStorageWrite(async () => {

const data = await chrome.storage.local.get(WPMySites.STORE_KEY);

const orig = data[WPMySites.STORE_KEY] || {};

// Migrate first, then apply: the popup canonicalizes its snapshot with

// the same pure migrateStore before rendering, so the key it sends is

// canonical and addresses the record regardless of whether a queued

// login re-keyed the persisted store in the meantime.

let next = WPMySites.migrateStore(orig);

if (op === 'remove') next = WPMySites.removeSite(next, key);

else if (op === 'rename') next = WPMySites.renameSite(next, key, name);

if (next !== orig) {

await chrome.storage.local.set({ [WPMySites.STORE_KEY]: next });

}

return next;

});

if (typeof ns !== 'string' || !ns) throw new Error('bad ns');

if (typeof key !== 'string' || !key) throw new Error('bad key');

const t = typeof value;

if (!(value === null || t === 'boolean' || t === 'number' || t === 'string')) {

throw new Error('bad value');

}

return enqueueStorageWrite(async () => {

const data = await chrome.storage.local.get(PREFS_KEY);

const root = data[PREFS_KEY] || {};

const next = { ...root, [ns]: { ...(root[ns] || {}), [key]: value } };

await chrome.storage.local.set({ [PREFS_KEY]: next });

return next;

});

await wipeLegacyCache();

// Canonicalize a pre-#94 origin-keyed My Sites store proactively so the

// popup renders canonical keys from its first open after an update; the

// per-write migrateStore in recordLogin/mutateMySites stays as the

// defensive backstop.

await enqueueStorageWrite(async () => {

const data = await chrome.storage.local.get(WPMySites.STORE_KEY);

const orig = data[WPMySites.STORE_KEY] || {};

const next = WPMySites.migrateStore(orig);

if (next !== orig) {

await chrome.storage.local.set({ [WPMySites.STORE_KEY]: next });

}

});

await purgeStale();

await repaintAllTabs();

let tabs;

try { tabs = await chrome.tabs.query({}); } catch (_) { return; }

const entries = await getAllEntries();

for (const tab of tabs) {

if (!tab.id || !tab.url || !/^https?:/.test(tab.url)) continue;

try {

const origin = new URL(tab.url).origin;

const entry = entries[origin];

await updateToolbar(

tab.id,

entry?.isWordPress || false,

{ isLoggedIn: entry?.isLoggedIn || false },

);

} catch (_) { /* invalid URL or tab closed */ }

}

if (sender && sender.origin) return sender.origin;

try {

return sender && sender.tab && sender.tab.url ? new URL(sender.tab.url).origin : null;

} catch (_) {

return null;

}

const url = (sender && sender.url)

|| (sender && sender.tab && sender.tab.url)

|| null;

if (!url) return null;

try {

return new URL(url).pathname;

} catch (_) {

return null;

}

try {

return !!(sender && sender.url && sender.url.startsWith(chrome.runtime.getURL('')));

} catch (_) {

return false;

}

if (!sessionStore) return { ...previewWindowsFallback };

try {

const data = await sessionStore.get(PREVIEW_WINDOWS_KEY);

return data[PREVIEW_WINDOWS_KEY] || {};

} catch (_) {

return {};

}

if (!sessionStore) { previewWindowsFallback = map; return; }

try {

await sessionStore.set({ [PREVIEW_WINDOWS_KEY]: map });

} catch (_) { /* ignore — worst case is one duplicate window */ }

if (typeof url !== 'string' || !url) return;

let origin;

try {

origin = new URL(url).origin;

} catch (_) {

return; // not a URL we can key — the popup never sends these

}

const windows = await getPreviewWindows();

const existingId = windows[origin];

if (existingId != null) {

try {

// populate:true exposes the window's tab id (never gated — only url and

// title need the tabs permission), which tabs.update needs to navigate.

const win = await chrome.windows.get(existingId, { populate: true });

const tab = win.tabs && win.tabs[0];

if (tab && tab.id != null) await chrome.tabs.update(tab.id, { url });

await chrome.windows.update(existingId, { focused: true });

return;

} catch (_) {

delete windows[origin]; // stale id — fall through and open fresh

}

}

let win;

try {

win = await chrome.windows.create({ url, type: 'popup', width: PREVIEW_W, height: PREVIEW_H });

} catch (err) {

await setPreviewWindows(windows); // persist the stale-id eviction above

throw err; // surfaces as { ok: false } to the popup

}

if (win && win.id != null) {

windows[origin] = win.id;

if (enforceSize) enforcePreviewSize(win.id, PREVIEW_W, PREVIEW_H);

}

await setPreviewWindows(windows);

if (winId == null) return;

for (let i = 0; i < 10; i++) {

await new Promise((resolve) => setTimeout(resolve, 150));

let win;

try {

win = await chrome.windows.get(winId);

} catch (_) {

return; // window closed

}

if (win.state === 'normal' && Math.abs((win.width || 0) - width) <= 40) return; // sized + un-maximized

try {

// state:'normal' clears the maximized/zoomed state the window inherited

// from its parent, so dragging it doesn't snap back to the parent's width.

await chrome.windows.update(winId, { state: 'normal', width, height });

} catch (_) {

return;

}

}

const {

origin, tabId, isLoggedIn, isWordPress, baseUrl, restApiRoot,

baseUrlEvidence, siteIconUrl, pathname,

} = msg;

if (!origin) return;

const existing = await getEntry(origin);

if (existing) {

existing.isLoggedIn = !!isLoggedIn;

existing.lastSeen = Date.now();

await putEntry(origin, existing);

}

if (tabId) await updateToolbar(tabId, !!isWordPress, { isLoggedIn });

// Catches cookie-API logins the page DOM missed (logged-out HTML).

if (isWordPress && isLoggedIn) {

const path = typeof pathname === 'string' ? pathname : null;

await recordLogin(

origin,

evidenceBackedBase(origin, baseUrl, restApiRoot, baseUrlEvidence, path),

siteIconUrl,

path,

);

}

const { detection, hostFromDOM } = msg;

// Key off the browser-attested origin, not msg.origin: a compromised renderer

// could otherwise write or overwrite another origin's cache / My Sites entry.

const origin = originFromSender(sender);

if (!origin) return;

const now = Date.now();

const existing = await getEntry(origin);

// Decide whether to trust this detection or the cache.

// - If the current page strongly suggests WP, use it.

// - If not, keep the cached answer (the home page may have different

// signals than a deep page; headless WP setups especially).

const freshlyDetected = detection.isWordPress;

const cacheIsFresh = existing &&

existing.isWordPress &&

(now - existing.checkedAt) < REFRESH_INTERVAL;

// Host: prefer a fresh DOM signal, fall back to cached value.

const host = hostFromDOM || existing?.host || null;

const hostCheckedAt = hostFromDOM ? now : (existing?.hostCheckedAt || null);

const entry = {

origin,

isWordPress: freshlyDetected || cacheIsFresh || false,

confidence: Math.max(

detection.confidence,

existing ? existing.confidence : 0,

),

signals: detection.signals,

// Cached so the toolbar repaint after SW startup/install can show the

// active variant without waiting for fresh detection. May be stale if

// the user logs out elsewhere; corrected on next page load and by the

// popup pushing its cookie-API result via POPUP_DETECTION_RESOLVED.

isLoggedIn: !!detection.context?.isLoggedIn,

// Only advance checkedAt when we have a confident positive detection,

// so a single ambiguous page view doesn't reset the clock.

checkedAt: freshlyDetected

? now

: (existing?.checkedAt || now),

lastSeen: now,

host,

hostCheckedAt,

};

// If WordPress and the host badge is due, ask the content script to

// inspect response headers: a cached host on the refresh clock, a missing

// one on the shorter retry clock (see the interval constants). The probe's

// answer replaces whatever was cached, null included, so the badge always

// reflects the latest probe. Resolve before the first write so we don't

// write twice.

const hostInterval = entry.host ? HOST_REFRESH_INTERVAL : HOST_RETRY_INTERVAL;

const needsHostCheck = entry.isWordPress &&

(!entry.hostCheckedAt || (now - entry.hostCheckedAt) > hostInterval);

if (needsHostCheck) {

try {

const res = await chrome.tabs.sendMessage(

sender.tab.id, { type: 'RESOLVE_HOST_HEADERS' },

);

entry.host = res?.host || null;

entry.hostCheckedAt = now;

} catch (_) { /* content script gone */ }

}

await putEntry(origin, entry);

await updateToolbar(sender.tab.id, entry.isWordPress, detection.context);

// Add to "My Sites" on a logged-in WordPress install, keyed by the

// evidence-backed base. With no evidence, upsertOnLogin attributes the

// login to the existing record owning the pathname (browser-attested

// sender URL, not the message) or drops it — never a speculative

// bare-origin row. Removal is sticky, so no prior-state capture is needed.

if (entry.isWordPress && entry.isLoggedIn) {

const pathname = pathnameFromSender(sender);

await recordLogin(

origin,

evidenceBackedBase(

origin,

detection.context?.baseUrl,

detection.context?.restApiRoot,

detection.context?.baseUrlEvidence,

pathname,

),

detection.context?.siteIconUrl,

pathname,

);

}

// Three states: not WP (gray + slash), WP but not logged in (gray),

// WP + logged in (blue). On a tab-URL-change refresh the icon paints from

// the cached entry (including its isLoggedIn), then corrects when the

// content script reports in — early.js hints a logged-in→logged-out

// downgrade at DOMContentLoaded (#59) so a stale blue doesn't linger to

// document_idle.

const variant = !isWordPress ? '-inactive'

: context?.isLoggedIn ? '-active'

: '';

chrome.action.setIcon({

tabId,

path: {

16: `icons/icon-16${variant}.png`,

32: `icons/icon-32${variant}.png`,

},

}, ignoreLastError);

const title = isWordPress

? chrome.i18n.getMessage(context?.isLoggedIn ? 'toolbar_title_detected_logged_in' : 'toolbar_title_detected') // "WordPress detected — logged in" / "WordPress detected"

: chrome.i18n.getMessage('toolbar_title_default'); // "WordPress Browser Extension"

chrome.action.setTitle({ tabId, title }, ignoreLastError);