@planningcenter/topbar 12.1.0 → 12.1.1

package/dist/topbar.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@planningcenter/tapestry'), require('react'), require('@planningcenter/url'), require('@planningcenter/icons/paths/general'), require('@planningcenter/jolt-client'), require('use-sync-external-store/shim'), require('@planningcenter/tapestry-react'), require('@planningcenter/add-ons'), require('@planningcenter/icons/paths/church-center'), require('@planningcenter/icons/paths/people'), require('@planningcenter/icons/paths/toolbar'), require('react-calendly'), require('algoliasearch'), require('react-instantsearch-core'), require('react-transition-group'), require('@planningcenter/datetime-fmt')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@planningcenter/tapestry', 'react', '@planningcenter/url', '@planningcenter/icons/paths/general', '@planningcenter/jolt-client', 'use-sync-external-store/shim', '@planningcenter/tapestry-react', '@planningcenter/add-ons', '@planningcenter/icons/paths/church-center', '@planningcenter/icons/paths/people', '@planningcenter/icons/paths/toolbar', 'react-calendly', 'algoliasearch', 'react-instantsearch-core', 'react-transition-group', '@planningcenter/datetime-fmt'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.PLANNINGCENTER = global.PLANNINGCENTER || {}, global.PLANNINGCENTER.Topbar = {}), global.tapestry, global.react, global.pcoUrl, global.general, global.Jolt, global.shim, global.tapestryReact, global.addOns, global.churchCenter, global.people, global.toolbar, global.reactCalendly, global.algoliasearch, global.reactInstantsearchCore, global.reactTransitionGroup, global.datetimeFmt));
-})(this, (function (exports, tapestry, React, pcoUrl$1, general, Jolt, shim, tapestryReact, addOns, churchCenter, people, toolbar, reactCalendly, algoliasearch, reactInstantsearchCore, reactTransitionGroup, datetimeFmt) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@planningcenter/tapestry'), require('react'), require('@planningcenter/url'), require('@planningcenter/icons/paths/general'), require('@planningcenter/jolt-client'), require('use-sync-external-store/shim'), require('react/jsx-runtime'), require('@planningcenter/tapestry-react'), require('@planningcenter/add-ons'), require('@planningcenter/icons/paths/church-center'), require('@planningcenter/icons/paths/people'), require('@planningcenter/icons/paths/toolbar'), require('react-calendly'), require('algoliasearch'), require('react-instantsearch-core'), require('react-transition-group'), require('@planningcenter/datetime-fmt')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@planningcenter/tapestry', 'react', '@planningcenter/url', '@planningcenter/icons/paths/general', '@planningcenter/jolt-client', 'use-sync-external-store/shim', 'react/jsx-runtime', '@planningcenter/tapestry-react', '@planningcenter/add-ons', '@planningcenter/icons/paths/church-center', '@planningcenter/icons/paths/people', '@planningcenter/icons/paths/toolbar', 'react-calendly', 'algoliasearch', 'react-instantsearch-core', 'react-transition-group', '@planningcenter/datetime-fmt'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.PLANNINGCENTER = global.PLANNINGCENTER || {}, global.PLANNINGCENTER.Topbar = {}), global.tapestry, global.react, global.pcoUrl, global.general, global.Jolt, global.shim, null, global.tapestryReact, global.addOns, global.churchCenter, global.people, global.toolbar, global.reactCalendly, global.algoliasearch, global.reactInstantsearchCore, global.reactTransitionGroup, global.datetimeFmt));
+})(this, (function (exports, tapestry, React, pcoUrl$1, general, Jolt, shim, jsxRuntime, tapestryReact, addOns, churchCenter, people, toolbar, reactCalendly, algoliasearch, reactInstantsearchCore, reactTransitionGroup, datetimeFmt) { 'use strict';
 
   function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -2235,29 +2235,767 @@
   const appsMenuFormatter = apps => sortByAttribute("name")(apps).reduce((acc, item) => (item.name || "") === "Church Center" || (item.name || "") === "API" ? acc : item.name === "Home" ? [item, ...acc] : [...acc, item], []);
   const connectedPeopleMenuFormatter = connectedPeople => connectedPeople.slice().sort((a, b) => a.attributes["organization_name"].localeCompare(b.attributes["organization_name"]));
 
+  // Generated by scripts/write-version.cjs from package.json. Do not edit.
+  const BRIDGE_VERSION = "0.0.8";
+
+  /**
+   * PCA_BRIDGE_BUS_INIT — the script injected via
+   * `injectedJavaScriptBeforeContentLoaded` before any web content loads.
+   *
+   * Installs `window.__pcaBridge` in the WebView's JS context. The bus:
+   *   - is per-WebView-context-by-construction (each WebView has its own JS
+   *     context; the global lives only in that context)
+   *   - accepts multiple registered handlers per reserved message type so
+   *     multiple Bridge instances in the same WebView can coexist
+   *   - buffers messages of a type with no registered handlers for up to 5s
+   *   - pings native with `__bridge/busReady` after install so the native
+   *     transport can flush its outgoing queue and trigger `reannounceLocal()`
+   *
+   * The bus runs as an IIFE so consumers can dispatch and register against it
+   * immediately. Internal state (buffers, handlers) is closure-private.
+   */
+
+  const PCA_BRIDGE_BUS_INIT = `
+(function () {
+  if (typeof window === 'undefined') return
+  if (window.__pcaBridge) return  // idempotent in case it's injected twice
+
+  var BRIDGE_VERSION = ${JSON.stringify(BRIDGE_VERSION)}
+  var BUFFER_TTL_MS = 5000
+  var handlers = Object.create(null)  // type -> Array<fn>
+  var buffer = Object.create(null)    // type -> Array<{msg, receivedAt}>
+  var logger = {
+    debug: function () {},
+    warn: function (msg, ctx) {
+      try { console.warn('[pca-bridge]', msg, ctx) } catch (e) {}
+    },
+    error: function (msg, ctx) {
+      try { console.error('[pca-bridge]', msg, ctx) } catch (e) {}
+    }
+  }
+
+  function now() { return Date.now() }
+
+  function sweepBuffer() {
+    var cutoff = now() - BUFFER_TTL_MS
+    var dropped = []
+    var hasAny = false
+    for (var type in buffer) {
+      var entries = buffer[type]
+      var kept = []
+      for (var i = 0; i < entries.length; i++) {
+        if (entries[i].receivedAt >= cutoff) {
+          kept.push(entries[i])
+        } else {
+          dropped.push({ type: type, ageMs: now() - entries[i].receivedAt })
+        }
+      }
+      if (kept.length === 0) delete buffer[type]
+      else {
+        buffer[type] = kept
+        hasAny = true
+      }
+    }
+    if (dropped.length > 0 && window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function') {
+      try {
+        window.ReactNativeWebView.postMessage(JSON.stringify({
+          type: '__bridge/drop',
+          bridgeVersion: BRIDGE_VERSION,
+          messages: dropped
+        }))
+      } catch (e) {}
+    }
+    // Stop ticking when the buffer drains; ensureSweep() restarts on demand.
+    if (!hasAny && sweepInterval !== null) {
+      clearInterval(sweepInterval)
+      sweepInterval = null
+    }
+  }
+
+  var sweepInterval = null
+  function ensureSweep() {
+    if (sweepInterval !== null) return
+    sweepInterval = setInterval(sweepBuffer, 1000)
+  }
+
+  function register(type, fn) {
+    if (!handlers[type]) handlers[type] = []
+    handlers[type].push(fn)
+    // Drain any buffered messages for this type, applying the same TTL the
+    // background sweep uses so entries that already expired don't get
+    // delivered just because sweep hasn't run yet.
+    var pending = buffer[type]
+    if (pending && pending.length > 0) {
+      delete buffer[type]
+      var cutoff = now() - BUFFER_TTL_MS
+      for (var i = 0; i < pending.length; i++) {
+        if (pending[i].receivedAt < cutoff) continue
+        try { fn(pending[i].msg) } catch (e) {
+          logger.error('Handler threw while draining buffer', { type: type, error: e })
+        }
+      }
+    }
+  }
+
+  function unregister(type, fn) {
+    var arr = handlers[type]
+    if (!arr) return
+    var idx = arr.indexOf(fn)
+    if (idx >= 0) arr.splice(idx, 1)
+    if (arr.length === 0) delete handlers[type]
+  }
+
+  function dispatch(msg) {
+    if (!msg || typeof msg !== 'object' || typeof msg.type !== 'string') return
+    var type = msg.type
+    var arr = handlers[type]
+    if (arr && arr.length > 0) {
+      // Snapshot the array to avoid issues if a handler registers/unregisters during dispatch
+      var snapshot = arr.slice()
+      for (var i = 0; i < snapshot.length; i++) {
+        try { snapshot[i](msg) } catch (e) {
+          logger.error('Handler threw during dispatch', { type: type, error: e })
+        }
+      }
+    } else {
+      if (!buffer[type]) buffer[type] = []
+      buffer[type].push({ msg: msg, receivedAt: now() })
+      ensureSweep()
+    }
+  }
+
+  function setLogger(next) {
+    // Validate both methods the bus actually calls; a partial logger would
+    // throw TypeError when dispatch/register tries to invoke a missing one.
+    if (next && typeof next.warn === 'function' && typeof next.error === 'function') {
+      logger = next
+    }
+  }
+
+  window.__pcaBridge = {
+    register: register,
+    unregister: unregister,
+    dispatch: dispatch,
+    setLogger: setLogger
+  }
+
+  // Ping native: the bus is ready in this JS context. Native transport
+  // listens for this to (a) flush its outgoing queue and (b) call
+  // bridge.reannounceLocal() so the freshly-loaded web context learns about
+  // already-exposed local actions/values.
+  try {
+    if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function') {
+      window.ReactNativeWebView.postMessage(JSON.stringify({ type: '__bridge/busReady', bridgeVersion: BRIDGE_VERSION }))
+    }
+  } catch (e) {}
+})();
+true;
+`;
+
+  class TimeoutError extends Error {
+    constructor(name, timeoutMs) {
+      super(`Call to "${name}" timed out after ${timeoutMs}ms`);
+      this.name = 'TimeoutError';
+    }
+  }
+  class HandlerError extends Error {
+    constructor(name, code, originalMessage) {
+      super(`Handler for "${name}" threw [${code}]: ${originalMessage}`);
+      this.name = 'HandlerError';
+    }
+  }
+  class DisposedError extends Error {
+    constructor(name) {
+      super(`Bridge disposed while call to "${name}" was in flight`);
+      this.name = 'DisposedError';
+    }
+  }
+
+  let idCounter = 0;
+  function generateId() {
+    idCounter += 1;
+    return `pca-bridge-${idCounter}`;
+  }
+  const noopLogger = {
+    debug: () => {},
+    warn: () => {},
+    error: () => {}
+  };
+  function isIndexable(x) {
+    return typeof x === 'object' && x !== null;
+  }
+
+  /**
+   * Shallow equality, one level deep. Used by `BridgeCore.publish` to dedup
+   * re-emissions of new-but-content-equal values (e.g., a freshly-built
+   * `modalButtons` array whose contents didn't change between renders).
+   */
+  function shallowEqual(a, b) {
+    const sameRef = Object.is(a, b);
+    const bothComparableObjects = isIndexable(a) && isIndexable(b) && Array.isArray(a) === Array.isArray(b);
+    let result;
+    if (sameRef) {
+      result = true;
+    } else if (!bothComparableObjects) {
+      result = false;
+    } else {
+      const keys = Object.keys(a);
+      result = keys.length === Object.keys(b).length && keys.every(k => Object.prototype.hasOwnProperty.call(b, k) && Object.is(a[k], b[k]));
+    }
+    return result;
+  }
+  function isWireEnvelope(parsed) {
+    return typeof parsed === 'object' && parsed !== null && 'type' in parsed && typeof parsed.type === 'string' && parsed.type.startsWith('__bridge/') && 'bridgeVersion' in parsed && typeof parsed.bridgeVersion === 'string';
+  }
+  function parseWireEnvelope(rawData) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawData);
+    } catch {
+      parsed = null;
+    }
+    return isWireEnvelope(parsed) ? parsed : null;
+  }
+
+  const DEFAULT_TIMEOUT_MS = 5000;
+  const INCOMING_CALL_QUEUE_TTL_MS = 5000;
+  const INCOMING_CALL_QUEUE_MAX_PER_ACTION = 32;
+  class BridgeCore {
+    injectedJavaScriptBeforeContentLoaded = PCA_BRIDGE_BUS_INIT;
+    localVersion = BRIDGE_VERSION;
+    // `never` arg type lets us widen any user-defined `LocalActions[K]` callable
+    // with a single `as` cast inside `expose()`.
+    localActions = new Map();
+    localValues = new Map();
+    remoteActions = new Set();
+    remoteValues = new Map();
+    actionListeners = new Map();
+    valueListeners = new Map();
+    pendingCalls = new Map();
+    callQueue = new Map();
+
+    // Private backing field + public getter so the `readonly` declared on the
+    // Bridge interface is actually enforced — not just at the interface level
+    // but for any code holding a concrete BridgeCore reference.
+    _remoteVersion = undefined;
+    get remoteVersion() {
+      return this._remoteVersion;
+    }
+    disposed = false;
+    constructor(options) {
+      const sendRaw = options.send;
+      this.send = msg => {
+        sendRaw({
+          ...msg,
+          bridgeVersion: BRIDGE_VERSION
+        });
+      };
+      this.logger = options.logger ?? noopLogger;
+      this.defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+      this.now = options.now ?? Date.now;
+    }
+    call(name, args, options) {
+      const requestId = generateId();
+      const timeoutMs = options?.timeoutMs ?? this.defaultTimeoutMs;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          if (this.pendingCalls.delete(requestId)) {
+            reject(new TimeoutError(name, timeoutMs));
+          }
+        }, timeoutMs);
+        // Heterogeneous map: cast the typed resolve to the loose storage slot.
+        this.pendingCalls.set(requestId, {
+          name,
+          resolve: resolve,
+          reject,
+          timer
+        });
+        this.send({
+          type: '__bridge/call',
+          requestId,
+          name,
+          args
+        });
+      });
+    }
+    expose(name, handler) {
+      if (this.localActions.has(name)) {
+        this.logger.warn('Action already exposed; last-write-wins (the previous handler is gone)', {
+          name
+        });
+      }
+      this.localActions.set(name, handler);
+      this.send({
+        type: '__bridge/exposed',
+        name,
+        kind: 'action'
+      });
+      const queued = this.callQueue.get(name);
+      if (queued) {
+        this.callQueue.delete(name);
+        const cutoff = this.now() - INCOMING_CALL_QUEUE_TTL_MS;
+        for (const entry of queued) {
+          if (entry.receivedAt >= cutoff) {
+            void this.invokeLocalHandler(entry.msg);
+          } else {
+            this.logger.warn('Queued incoming call expired before handler registered', {
+              name,
+              ageMs: this.now() - entry.receivedAt
+            });
+            this.rejectQueued(entry, 'expired');
+          }
+        }
+      }
+    }
+    unexpose(name) {
+      if (this.localActions.delete(name)) {
+        this.send({
+          type: '__bridge/unexposed',
+          name,
+          kind: 'action'
+        });
+      }
+    }
+    hasRemoteAction(name) {
+      return this.remoteActions.has(name);
+    }
+    onRemoteAction(name, callback) {
+      let set = this.actionListeners.get(name);
+      if (!set) {
+        set = new Set();
+        this.actionListeners.set(name, set);
+      }
+      set.add(callback);
+      return () => {
+        const current = this.actionListeners.get(name);
+        if (current) {
+          current.delete(callback);
+          if (current.size === 0) {
+            this.actionListeners.delete(name);
+          }
+        }
+      };
+    }
+    publish(name, value) {
+      // Skip wire send if content unchanged — callers may publish on every
+      // render with a fresh-but-content-equal value.
+      if (!shallowEqual(this.localValues.get(name), value)) {
+        this.localValues.set(name, value);
+        this.send({
+          type: '__bridge/publish',
+          name,
+          value
+        });
+      }
+    }
+    unpublish(name) {
+      if (this.localValues.delete(name)) {
+        this.send({
+          type: '__bridge/unexposed',
+          name,
+          kind: 'value'
+        });
+      }
+    }
+    seedLocalValue(name, value) {
+      this.localValues.set(name, value);
+    }
+    getRemoteValue(name) {
+      return this.remoteValues.get(name);
+    }
+    onRemoteValue(name, callback) {
+      let set = this.valueListeners.get(name);
+      if (!set) {
+        set = new Set();
+        this.valueListeners.set(name, set);
+      }
+      const wrapped = callback;
+      set.add(wrapped);
+      return () => {
+        const current = this.valueListeners.get(name);
+        if (current) {
+          current.delete(wrapped);
+          if (current.size === 0) {
+            this.valueListeners.delete(name);
+          }
+        }
+      };
+    }
+    reannounceLocal() {
+      for (const name of this.localActions.keys()) {
+        this.send({
+          type: '__bridge/exposed',
+          name,
+          kind: 'action'
+        });
+      }
+      for (const [name, value] of this.localValues) {
+        this.send({
+          type: '__bridge/exposed',
+          name,
+          kind: 'value',
+          currentValue: value
+        });
+      }
+    }
+
+    /**
+     * Drop remote-side cached state. Called by transports when the remote JS
+     * context is about to be torn down (e.g., WebView reload): the new context
+     * will re-announce what it actually exposes, and stale entries would
+     * otherwise silently mask removed actions/values.
+     */
+    clearRemoteState() {
+      for (const name of this.remoteActions) {
+        this.notifySet(this.actionListeners, name, false, 'action availability');
+      }
+      this.remoteActions.clear();
+      for (const name of this.remoteValues.keys()) {
+        this.notifySet(this.valueListeners, name, undefined, 'remote value change');
+      }
+      this.remoteValues.clear();
+      this._remoteVersion = undefined;
+    }
+    handleMessage(rawData) {
+      const msg = parseWireEnvelope(rawData);
+      let consumed = false;
+      if (msg) {
+        this.handleIncomingMessage(msg);
+        consumed = true;
+      }
+      return consumed;
+    }
+    applyLogger(logger) {
+      if (this.logger === noopLogger) {
+        this.logger = logger;
+        return true;
+      }
+      return false;
+    }
+    handleLoadStart() {}
+    handleLoadEnd() {}
+    handleNavigationStateChange(navState) {
+      if (!navState.loading) {
+        this.handleLoadEnd();
+      }
+    }
+    handleIncomingMessage(msg) {
+      if (!this.disposed) {
+        this._remoteVersion = msg.bridgeVersion;
+        switch (msg.type) {
+          case '__bridge/call':
+            void this.routeIncomingCall(msg);
+            break;
+          case '__bridge/response':
+            this.handleIncomingResponse(msg);
+            break;
+          case '__bridge/exposed':
+            this.handleIncomingExposed(msg);
+            break;
+          case '__bridge/unexposed':
+            this.handleIncomingUnexposed(msg);
+            break;
+          case '__bridge/publish':
+            this.handleIncomingPublish(msg);
+            break;
+          case '__bridge/busReady':
+          case '__bridge/drop':
+            break;
+          default:
+            {
+              // parseWireEnvelope admits any `__bridge/*` type; this catches
+              // future message types a remote on a newer bridge sends to us.
+              const unknown = msg;
+              this.logger.warn('Received unknown bridge message type; ignoring', {
+                type: unknown.type,
+                remoteVersion: this.remoteVersion
+              });
+              break;
+            }
+        }
+      }
+    }
+    get debug() {
+      return {
+        listLocalActions: () => Array.from(this.localActions.keys()),
+        listRemoteActions: () => Array.from(this.remoteActions),
+        listLocalValues: () => Array.from(this.localValues.keys()),
+        listRemoteValues: () => Array.from(this.remoteValues.keys())
+      };
+    }
+    dispose() {
+      if (!this.disposed) {
+        this.disposed = true;
+        for (const pending of this.pendingCalls.values()) {
+          clearTimeout(pending.timer);
+          pending.reject(new DisposedError(pending.name));
+        }
+        this.pendingCalls.clear();
+        this.callQueue.clear();
+      }
+    }
+    async routeIncomingCall(msg) {
+      if (this.localActions.has(msg.name)) {
+        await this.invokeLocalHandler(msg);
+        return;
+      }
+      let queued = this.callQueue.get(msg.name);
+      if (!queued) {
+        queued = [];
+        this.callQueue.set(msg.name, queued);
+      }
+      // Evict TTL-expired and over-capacity entries so a remote that spams an
+      // unknown action can't grow the queue without bound. Each evicted call
+      // gets an error response so the caller fails fast.
+      const cutoff = this.now() - INCOMING_CALL_QUEUE_TTL_MS;
+      while (queued.length > 0) {
+        const head = queued[0];
+        if (!head || head.receivedAt >= cutoff) break;
+        queued.shift();
+        this.rejectQueued(head, 'expired');
+      }
+      while (queued.length >= INCOMING_CALL_QUEUE_MAX_PER_ACTION) {
+        const evicted = queued.shift();
+        if (!evicted) break;
+        this.rejectQueued(evicted, 'queue_full');
+      }
+      queued.push({
+        msg,
+        receivedAt: this.now()
+      });
+    }
+    rejectQueued(entry, code) {
+      this.send({
+        type: '__bridge/response',
+        requestId: entry.msg.requestId,
+        ok: false,
+        code,
+        message: `Queued call to "${entry.msg.name}" dropped (${code})`
+      });
+    }
+    async invokeLocalHandler(msg) {
+      // Handler may have been unregistered between queue push and drain. Reply
+      // with an explicit error so the caller fails fast instead of timing out.
+      const handler = this.localActions.get(msg.name);
+      if (!handler) {
+        this.send({
+          type: '__bridge/response',
+          requestId: msg.requestId,
+          ok: false,
+          code: 'unexposed',
+          message: `No handler exposed for "${msg.name}"`
+        });
+        return;
+      }
+      try {
+        const result = await handler(msg.args);
+        this.send({
+          type: '__bridge/response',
+          requestId: msg.requestId,
+          ok: true,
+          result
+        });
+      } catch (error) {
+        this.send({
+          type: '__bridge/response',
+          requestId: msg.requestId,
+          ok: false,
+          code: 'thrown',
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    handleIncomingResponse(msg) {
+      const pending = this.pendingCalls.get(msg.requestId);
+      if (pending) {
+        this.pendingCalls.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.ok) {
+          pending.resolve(msg.result);
+        } else {
+          pending.reject(new HandlerError(pending.name, msg.code, msg.message));
+        }
+      } else {
+        this.logger.warn('Response for unknown or already-resolved requestId', {
+          requestId: msg.requestId
+        });
+      }
+    }
+    handleIncomingExposed(msg) {
+      if (msg.kind === 'action') {
+        if (!this.remoteActions.has(msg.name)) {
+          this.remoteActions.add(msg.name);
+          this.notifySet(this.actionListeners, msg.name, true, 'action availability');
+        }
+      } else {
+        this.remoteValues.set(msg.name, msg.currentValue);
+        this.notifySet(this.valueListeners, msg.name, msg.currentValue, 'remote value change');
+      }
+    }
+    handleIncomingUnexposed(msg) {
+      if (msg.kind === 'action') {
+        if (this.remoteActions.delete(msg.name)) {
+          this.notifySet(this.actionListeners, msg.name, false, 'action availability');
+        }
+      } else if (this.remoteValues.delete(msg.name)) {
+        this.notifySet(this.valueListeners, msg.name, undefined, 'remote value change');
+      }
+    }
+    handleIncomingPublish(msg) {
+      this.remoteValues.set(msg.name, msg.value);
+      this.notifySet(this.valueListeners, msg.name, msg.value, 'remote value change');
+    }
+    notifySet(subs, name, value, label) {
+      const set = subs.get(name);
+      if (set) {
+        for (const callback of set) {
+          try {
+            callback(value);
+          } catch (error) {
+            this.logger.error(`Subscriber threw during ${label} notification`, {
+              name,
+              error
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // Subset of window.__pcaBridge that bridge_web.ts needs.
+
+  const INBOUND_TYPES = ['__bridge/call', '__bridge/response', '__bridge/exposed', '__bridge/unexposed', '__bridge/publish'];
+  class WebBridge extends BridgeCore {
+    constructor(options = {}) {
+      const bus = window.__pcaBridge;
+      super({
+        send: msg => {
+          if (window.ReactNativeWebView) {
+            try {
+              window.ReactNativeWebView.postMessage(JSON.stringify(msg));
+            } catch (error) {
+              options.logger?.error('WebBridge postMessage failed', {
+                error
+              });
+            }
+          }
+        },
+        logger: options.logger,
+        defaultTimeoutMs: options.defaultTimeoutMs
+      });
+      this.bus = bus;
+      this.handlerFn = msg => {
+        this.handleIncomingMessage(msg);
+      };
+      if (bus) {
+        if (options.logger) {
+          bus.setLogger(options.logger);
+        }
+        for (const type of INBOUND_TYPES) {
+          bus.register(type, this.handlerFn);
+        }
+        if (window.ReactNativeWebView) {
+          try {
+            window.ReactNativeWebView.postMessage(JSON.stringify({
+              type: '__bridge/busReady',
+              bridgeVersion: BRIDGE_VERSION
+            }));
+          } catch (error) {
+            options.logger?.error('WebBridge busReady post failed', {
+              error
+            });
+          }
+        }
+      } else {
+        options.logger?.warn('WebBridge constructed without window.__pcaBridge — bus init script may not have run');
+      }
+    }
+    applyLogger(logger) {
+      const applied = super.applyLogger(logger);
+      if (applied && this.bus) {
+        this.bus.setLogger(logger);
+      }
+      return applied;
+    }
+    dispose() {
+      if (this.bus) {
+        for (const type of INBOUND_TYPES) {
+          this.bus.unregister(type, this.handlerFn);
+        }
+      }
+      super.dispose();
+    }
+  }
+  function getOrCreateWebBridge(options = {}) {
+    if (window.__pcaWebBridge && options.logger) {
+      window.__pcaWebBridge.applyLogger(options.logger);
+    } else if (!window.__pcaWebBridge) {
+      window.__pcaWebBridge = new WebBridge(options);
+    }
+    return window.__pcaWebBridge;
+  }
+
+  const WebBridgeContext = /*#__PURE__*/React.createContext(null);
+  function useWebBridge() {
+    const ctxBridge = React.useContext(WebBridgeContext);
+    if (ctxBridge) {
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+      return ctxBridge;
+    } else {
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+      return getOrCreateWebBridge();
+    }
+  }
+  function useBridgePublish(bridge, name, value) {
+    // publish() dedups by shallow equality, so this effect is safe to re-run
+    // on every value change without spamming wire messages.
+    React.useEffect(() => {
+      bridge.publish(name, value);
+    }, [bridge, name, value]);
+    React.useEffect(() => {
+      return () => {
+        bridge.unpublish(name);
+      };
+    }, [bridge, name]);
+  }
+
   const useSetCurrentRouteInfo = ({
     routes,
     app
   }) => {
+    const bridge = useWebBridge();
+    const currentRoutes = React.useMemo(() => routes.map(({
+      key,
+      props: {
+        to,
+        href,
+        active
+      }
+    }) => ({
+      active,
+      name: key,
+      url: to !== null && to !== void 0 ? to : href
+    })), [routes]);
+    useBridgePublish(bridge, "routeInfo", {
+      currentApp: app,
+      currentRoutes
+    });
+    // Legacy support for older versions of PCA
     React.useEffect(() => {
       if (window.topbar) {
         window.topbar.routeInfo = {
           currentApp: app,
-          currentRoutes: routes.map(({
-            key,
-            props: {
-              to,
-              href,
-              active
-            }
-          }) => ({
-            active,
-            name: key,
-            url: to !== null && to !== void 0 ? to : href
-          }))
+          currentRoutes
         };
       }
     }, [routes, app]);
+    // Publish info for when app goes back
+    React.useEffect(() => window.addEventListener("pageshow", () => {
+      bridge.publish("routeInfo", {
+        currentApp: app,
+        currentRoutes
+      });
+    }), []);
   };
 
   const useUpdateStore = () => React.useCallback(updates => {