跨标签页事件总线设计：消息协议、存储降级与并发控制

const tabId = crypto.randomUUID();
const channel = new BroadcastChannel('haoge-app-events-v1');

function publish(type, payload) {
  channel.postMessage({
    version: 1,
    id: crypto.randomUUID(),
    source: tabId,
    type,
    payload,
    sentAt: Date.now(),
  });
}

function onMessage(event) {
  const message = event.data;
  if (!message || message.version !== 1 || message.source === tabId) return;
  if (typeof message.id !== 'string' || typeof message.type !== 'string') return;

  if (message.type === 'logout') {
    clearPrivateViewState();
    refreshServerSession();
  } else if (message.type === 'document-invalidated') {
    refetchDocumentIfOpen(message.payload?.documentId);
  }
}

channel.addEventListener('message', onMessage);

function disposeChannel() {
  channel.removeEventListener('message', onMessage);
  channel.close();
}

function createMessageId() {
  if (crypto.randomUUID) return crypto.randomUUID();
  return Array.from(crypto.getRandomValues(new Uint8Array(16)),
    (byte) => byte.toString(16).padStart(2, '0')).join('');
}

function createCrossTabBus(name) {
  const senderId = createMessageId();
  const storageKey = name + ':fallback';
  const listeners = new Set();
  const seen = new Set();
  let channel = null;
  let closed = false;

  try {
    if (typeof BroadcastChannel !== 'undefined') channel = new BroadcastChannel(name);
  } catch {
    channel = null;
  }

  function dispatch(value) {
    if (!value || value.version !== 1 || typeof value.id !== 'string' ||
        typeof value.senderId !== 'string' || typeof value.type !== 'string' ||
        typeof value.sentAt !== 'number' || seen.has(value.id)) return;
    seen.add(value.id);
    if (seen.size > 512) seen.delete(seen.values().next().value);
    for (const listener of listeners) {
      try { listener(value); } catch { /* Report through sanitized diagnostics. */ }
    }
  }

  const onMessage = (event) => dispatch(event.data);
  const onStorage = (event) => {
    if (event.key !== storageKey || !event.newValue) return;
    try { dispatch(JSON.parse(event.newValue)); } catch { /* Ignore malformed data. */ }
  };
  channel?.addEventListener('message', onMessage);
  window.addEventListener('storage', onStorage);

  return {
    emit(type, payload) {
      if (closed) throw new Error('Cross-tab bus is closed');
      const message = { version: 1, id: createMessageId(), senderId, type, sentAt: Date.now(), payload };
      const encoded = JSON.stringify(message);
      dispatch(message);
      try {
        if (channel) channel.postMessage(message);
        else localStorage.setItem(storageKey, encoded);
      } catch {
        try { localStorage.setItem(storageKey, encoded); }
        catch { throw new Error('Cross-tab message could not be sent'); }
      }
    },
    subscribe(listener) {
      if (closed) throw new Error('Cross-tab bus is closed');
      listeners.add(listener);
      return () => listeners.delete(listener);
    },
    close() {
      if (closed) return;
      closed = true;
      channel?.removeEventListener('message', onMessage);
      channel?.close();
      window.removeEventListener('storage', onStorage);
      listeners.clear();
    },
  };
}

async function syncOnceAcrossTabs(signal) {
  if (!navigator.locks) return runWithPerTabFallback();

  return navigator.locks.request(
    'haoge-app-cache-sync-v1',
    { ifAvailable: true, signal },
    async (lock) => {
      if (!lock) return { skipped: true };
      await refreshSharedCache({ signal });
      publish('cache-invalidated', { revision: getCurrentRevision() });
      return { skipped: false };
    },
  );
}