agent-embassy 1.0.0

package/dist/src/gateway/live-dashboard-app/app.js

@@ -0,0 +1,2914 @@
+"use strict";
+var Embassy;
+(function (Embassy) {
+    Embassy.DEFAULT_CLOCK_TICK_MS = 30_000;
+    function useNowMs(tickMs = Embassy.DEFAULT_CLOCK_TICK_MS) {
+        const [nowMs, setNowMs] = React.useState(() => Date.now());
+        React.useEffect(() => {
+            const handle = window.setInterval(() => {
+                setNowMs(Date.now());
+            }, tickMs);
+            return () => {
+                window.clearInterval(handle);
+            };
+        }, [tickMs]);
+        return nowMs;
+    }
+    Embassy.useNowMs = useNowMs;
+    const absoluteFormatters = new Map();
+    const relativeFormatters = new Map();
+    function absoluteFormatter(locale) {
+        const existing = absoluteFormatters.get(locale);
+        if (existing !== undefined)
+            return existing;
+        const formatter = new Intl.DateTimeFormat(locale, {
+            month: "short",
+            day: "numeric",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        });
+        absoluteFormatters.set(locale, formatter);
+        return formatter;
+    }
+    function relativeFormatter(locale) {
+        const existing = relativeFormatters.get(locale);
+        if (existing !== undefined)
+            return existing;
+        const formatter = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+        relativeFormatters.set(locale, formatter);
+        return formatter;
+    }
+    function fmtAbs(iso, locale) {
+        const milliseconds = Date.parse(iso);
+        if (!Number.isFinite(milliseconds))
+            return iso;
+        return absoluteFormatter(locale).format(new Date(milliseconds));
+    }
+    Embassy.fmtAbs = fmtAbs;
+    function fmtRel(iso, nowMs, locale) {
+        const milliseconds = Date.parse(iso);
+        if (!Number.isFinite(milliseconds))
+            return iso;
+        const deltaSeconds = Math.round((milliseconds - nowMs) / 1000);
+        const magnitude = Math.abs(deltaSeconds);
+        const formatter = relativeFormatter(locale);
+        if (magnitude < 60)
+            return formatter.format(deltaSeconds, "second");
+        if (magnitude < 3_600) {
+            return formatter.format(Math.trunc(deltaSeconds / 60), "minute");
+        }
+        if (magnitude < 86_400) {
+            return formatter.format(Math.trunc(deltaSeconds / 3_600), "hour");
+        }
+        return formatter.format(Math.trunc(deltaSeconds / 86_400), "day");
+    }
+    Embassy.fmtRel = fmtRel;
+    function fmtAge(ms) {
+        const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+        if (totalSeconds < 60)
+            return `${totalSeconds}s`;
+        const totalMinutes = Math.floor(totalSeconds / 60);
+        if (totalMinutes < 60)
+            return `${totalMinutes}m ${totalSeconds % 60}s`;
+        const totalHours = Math.floor(totalMinutes / 60);
+        if (totalHours < 24)
+            return `${totalHours}h ${totalMinutes % 60}m`;
+        return `${Math.floor(totalHours / 24)}d ${totalHours % 24}h`;
+    }
+    Embassy.fmtAge = fmtAge;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    Embassy.CHIP_KINDS = [
+        "positive",
+        "qualified",
+        "active",
+        "progress",
+        "warning",
+        "indeterminate",
+        "failure",
+        "inert",
+        "unknown",
+    ];
+    function tableLookup(table, state) {
+        return Object.prototype.hasOwnProperty.call(table, state)
+            ? table[state]
+            : "unknown";
+    }
+    const DELIVERY_CHIP_KINDS = {
+        queued: "progress",
+        dispatching: "progress",
+        transport_written: "progress",
+        held: "progress",
+        duplicate: "inert",
+        delivered: "positive",
+        unconfirmed: "indeterminate",
+        ambiguous: "indeterminate",
+        failed: "failure",
+        expired: "failure",
+        rejected: "warning",
+        cancelled: "inert",
+        abandoned: "inert",
+    };
+    const ROUTE_CHIP_KINDS = {
+        idle: "progress",
+        busy: "active",
+        awaiting_approval: "warning",
+        stale: "failure",
+        offline: "failure",
+        incompatible: "failure",
+        disabled: "inert",
+    };
+    const PEER_CHIP_KINDS = {
+        idle: "progress",
+        busy: "active",
+        awaiting_approval: "warning",
+        offline: "inert",
+        incompatible: "failure",
+    };
+    const HEALTH_CHIP_KINDS = {
+        healthy: "positive",
+        connecting: "progress",
+        degraded: "warning",
+        offline: "failure",
+        incompatible: "failure",
+    };
+    const COMPATIBILITY_CHIP_KINDS = {
+        compatible: "positive",
+        unknown: "inert",
+        expired: "warning",
+        incompatible: "failure",
+    };
+    const OVERALL_CHIP_KINDS = {
+        ready: "positive",
+        setup: "progress",
+        attention: "failure",
+    };
+    const PARTY_CHIP_KINDS = {
+        ready: "positive",
+        busy: "active",
+        waiting: "warning",
+        missing: "inert",
+        attention: "failure",
+    };
+    const SEVERITY_CHIP_KINDS = {
+        info: "active",
+        warning: "warning",
+        error: "failure",
+    };
+    const CONNECTION_CHIP_KINDS = {
+        connected: "positive",
+        connecting: "progress",
+        paused: "inert",
+        unavailable: "warning",
+        disconnected: "warning",
+        stopped: "warning",
+    };
+    function chipKindFor(state, direction, safeErrorCode) {
+        if (state === "rejected" && safeErrorCode === "SENDER_NOT_PAIRED") {
+            return "inert";
+        }
+        if (state === "delivered" && direction === "codex_to_claude") {
+            return "qualified";
+        }
+        return tableLookup(DELIVERY_CHIP_KINDS, state);
+    }
+    Embassy.chipKindFor = chipKindFor;
+    function routeChipKind(state) {
+        return tableLookup(ROUTE_CHIP_KINDS, state);
+    }
+    Embassy.routeChipKind = routeChipKind;
+    function peerChipKind(state) {
+        return tableLookup(PEER_CHIP_KINDS, state);
+    }
+    Embassy.peerChipKind = peerChipKind;
+    function healthChipKind(state) {
+        return tableLookup(HEALTH_CHIP_KINDS, state);
+    }
+    Embassy.healthChipKind = healthChipKind;
+    function compatibilityChipKind(state) {
+        return tableLookup(COMPATIBILITY_CHIP_KINDS, state);
+    }
+    Embassy.compatibilityChipKind = compatibilityChipKind;
+    function overallChipKind(state) {
+        return tableLookup(OVERALL_CHIP_KINDS, state);
+    }
+    Embassy.overallChipKind = overallChipKind;
+    function partyChipKind(state) {
+        return tableLookup(PARTY_CHIP_KINDS, state);
+    }
+    Embassy.partyChipKind = partyChipKind;
+    function severityChipKind(state) {
+        return tableLookup(SEVERITY_CHIP_KINDS, state);
+    }
+    Embassy.severityChipKind = severityChipKind;
+    function connectionChipKind(state) {
+        return tableLookup(CONNECTION_CHIP_KINDS, state);
+    }
+    Embassy.connectionChipKind = connectionChipKind;
+    function chipKindByDomain(domain, state, direction) {
+        switch (domain) {
+            case "delivery":
+                return chipKindFor(state, direction);
+            case "route":
+                return routeChipKind(state);
+            case "peer":
+                return peerChipKind(state);
+            case "health":
+                return healthChipKind(state);
+            case "compatibility":
+                return compatibilityChipKind(state);
+            case "overall":
+                return overallChipKind(state);
+            case "party":
+                return partyChipKind(state);
+            case "severity":
+                return severityChipKind(state);
+            case "connection":
+                return connectionChipKind(state);
+        }
+    }
+    Embassy.chipKindByDomain = chipKindByDomain;
+    function camelCaseToken(token) {
+        return token.replace(/_([a-z])/g, (_match, character) => character.toUpperCase());
+    }
+    Embassy.camelCaseToken = camelCaseToken;
+    function deliveryMeaningKey(state, safeErrorCode, direction) {
+        switch (state) {
+            case "queued":
+                return "activity.meaning.queued";
+            case "dispatching":
+                return "activity.meaning.dispatching";
+            case "transport_written":
+                return "activity.meaning.transportWritten";
+            case "held":
+                return "activity.meaning.held";
+            case "duplicate":
+                return "activity.meaning.duplicate";
+            case "delivered":
+                return direction === "codex_to_claude"
+                    ? "activity.meaning.delivered.codexToClaude"
+                    : direction === "claude_to_codex"
+                        ? "activity.meaning.delivered.claudeToCodex"
+                        : "activity.meaning.delivered";
+            case "unconfirmed":
+                return "activity.meaning.unconfirmed";
+            case "ambiguous":
+                return "activity.meaning.ambiguous";
+            case "failed":
+                return "activity.meaning.failed";
+            case "expired":
+                return "activity.meaning.expired";
+            case "rejected":
+                return safeErrorCode === "SENDER_NOT_PAIRED"
+                    ? "activity.meaning.senderNotPaired"
+                    : "activity.meaning.rejected";
+            case "cancelled":
+                return "activity.meaning.cancelled";
+            case "abandoned":
+                switch (safeErrorCode) {
+                    case "CONTROLLER_RESTARTED":
+                        return "activity.meaning.abandoned.controllerRestarted";
+                    case "TRANSIENT_BODY_UNAVAILABLE":
+                        return "activity.meaning.abandoned.transientBody";
+                    case "ROUTE_UNREGISTERED":
+                    case "MESSAGE_EXPIRED":
+                        return "activity.meaning.abandoned.routeTerminated";
+                    default:
+                        return "activity.meaning.abandoned.generic";
+                }
+            default:
+                return "activity.meaning.other";
+        }
+    }
+    Embassy.deliveryMeaningKey = deliveryMeaningKey;
+    function meaningKeyFor(domain, state, safeErrorCode, direction) {
+        switch (domain) {
+            case "delivery":
+                return deliveryMeaningKey(state, safeErrorCode, direction);
+            case "route":
+                return `route.meaning.${camelCaseToken(state)}`;
+            case "peer":
+                return `peer.meaning.${camelCaseToken(state)}`;
+            case "health":
+                return `health.meaning.${camelCaseToken(state)}`;
+            case "compatibility":
+                return `compatibility.meaning.${camelCaseToken(state)}`;
+            case "overall":
+                return `overall.${camelCaseToken(state)}`;
+            case "party":
+                return `status.${camelCaseToken(state)}`;
+            case "severity":
+                return `severity.${camelCaseToken(state)}`;
+            case "connection":
+                return `live.connection.${state}`;
+        }
+    }
+    Embassy.meaningKeyFor = meaningKeyFor;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const PLACEHOLDER_PATTERN = /\{([A-Za-z][A-Za-z0-9]*)\}/g;
+    function interpolate(template, values = {}) {
+        return template.replace(PLACEHOLDER_PATTERN, (match, name) => Object.prototype.hasOwnProperty.call(values, name)
+            ? String(values[name])
+            : match);
+    }
+    Embassy.interpolate = interpolate;
+    const I18nContext = React.createContext(null);
+    function I18nProvider(props) {
+        const { copy, onLocaleChange } = props;
+        const [locale, setLocaleState] = React.useState(props.initialLocale);
+        const setLocale = React.useCallback((next) => {
+            setLocaleState(next);
+            if (onLocaleChange !== undefined)
+                onLocaleChange(next);
+        }, [onLocaleChange]);
+        const t = React.useCallback((key, values) => {
+            const template = copy[locale][key] ?? key;
+            return interpolate(template, values ?? {});
+        }, [copy, locale]);
+        const value = React.useMemo(() => ({ locale, setLocale, t }), [locale, setLocale, t]);
+        return (React.createElement(I18nContext.Provider, { value: value }, props.children));
+    }
+    Embassy.I18nProvider = I18nProvider;
+    function useI18n() {
+        const value = React.useContext(I18nContext);
+        if (value === null) {
+            throw new Error("Embassy.I18nProvider is missing above this component.");
+        }
+        return value;
+    }
+    function useT() {
+        return useI18n().t;
+    }
+    Embassy.useT = useT;
+    function useLocale() {
+        const { locale, setLocale } = useI18n();
+        return [locale, setLocale];
+    }
+    Embassy.useLocale = useLocale;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    Embassy.TERMINAL_DELIVERY_STATES = [
+        "delivered",
+        "unconfirmed",
+        "failed",
+        "ambiguous",
+        "expired",
+        "cancelled",
+        "abandoned",
+        "rejected",
+    ];
+    const TERMINAL_DELIVERY_STATE_SET = new Set(Embassy.TERMINAL_DELIVERY_STATES);
+    Embassy.PULSE_WINDOW_MS = 3_600_000;
+    const HEALTH_WORST_FIRST = [
+        "offline",
+        "incompatible",
+        "degraded",
+        "connecting",
+        "healthy",
+    ];
+    const COMPATIBILITY_WORST_FIRST = [
+        "incompatible",
+        "expired",
+        "unknown",
+        "compatible",
+    ];
+    function compareText(left, right) {
+        return left < right ? -1 : left > right ? 1 : 0;
+    }
+    function isTerminalDeliveryState(state) {
+        return TERMINAL_DELIVERY_STATE_SET.has(state);
+    }
+    Embassy.isTerminalDeliveryState = isTerminalDeliveryState;
+    function parseTimestampMs(iso) {
+        if (iso === undefined)
+            return undefined;
+        const milliseconds = Date.parse(iso);
+        return Number.isFinite(milliseconds) ? milliseconds : undefined;
+    }
+    Embassy.parseTimestampMs = parseTimestampMs;
+    function queueSplit(model, targetProvider, nowMs) {
+        let depth = 0;
+        let oldestQueuedAt;
+        let oldestQueuedMs;
+        for (const route of model.routes) {
+            if (route.provider !== targetProvider)
+                continue;
+            depth += route.queueDepth;
+            if (route.queueDepth === 0 || route.oldestQueuedAt === undefined) {
+                continue;
+            }
+            const queuedMs = parseTimestampMs(route.oldestQueuedAt);
+            if (queuedMs === undefined)
+                continue;
+            if (oldestQueuedMs === undefined || queuedMs < oldestQueuedMs) {
+                oldestQueuedMs = queuedMs;
+                oldestQueuedAt = route.oldestQueuedAt;
+            }
+        }
+        return {
+            depth,
+            depthIsLowerBound: model.omissions.routes > 0,
+            oldestQueuedAt,
+            oldestAgeMs: oldestQueuedMs === undefined
+                ? undefined
+                : Math.max(0, nowMs - oldestQueuedMs),
+        };
+    }
+    Embassy.queueSplit = queueSplit;
+    function routeOldestAgeMs(route, nowMs) {
+        if (route.queueDepth === 0 || route.oldestQueuedAt === undefined) {
+            return undefined;
+        }
+        const queuedMs = parseTimestampMs(route.oldestQueuedAt);
+        return queuedMs === undefined ? undefined : Math.max(0, nowMs - queuedMs);
+    }
+    Embassy.routeOldestAgeMs = routeOldestAgeMs;
+    function worstConnectorHealth(model, provider) {
+        let worst;
+        for (const connector of model.connectors) {
+            if (connector.provider !== provider)
+                continue;
+            if (worst === undefined ||
+                HEALTH_WORST_FIRST.indexOf(connector.health) <
+                    HEALTH_WORST_FIRST.indexOf(worst)) {
+                worst = connector.health;
+            }
+        }
+        return worst;
+    }
+    Embassy.worstConnectorHealth = worstConnectorHealth;
+    function worstCompatibility(model) {
+        let worst;
+        for (const connector of model.connectors) {
+            if (worst === undefined ||
+                COMPATIBILITY_WORST_FIRST.indexOf(connector.compatibility) <
+                    COMPATIBILITY_WORST_FIRST.indexOf(worst)) {
+                worst = connector.compatibility;
+            }
+        }
+        return worst;
+    }
+    Embassy.worstCompatibility = worstCompatibility;
+    function pulse(model) {
+        const generatedMs = parseTimestampMs(model.generatedAt);
+        const cutoffMs = generatedMs === undefined ? undefined : generatedMs - Embassy.PULSE_WINDOW_MS;
+        const counts = new Map();
+        for (const group of model.activity) {
+            if (!isTerminalDeliveryState(group.state))
+                continue;
+            if (cutoffMs !== undefined) {
+                const timestampMs = parseTimestampMs(group.timestamp);
+                if (timestampMs === undefined || timestampMs < cutoffMs)
+                    continue;
+            }
+            counts.set(group.state, (counts.get(group.state) ?? 0) + 1);
+        }
+        const bars = Embassy.TERMINAL_DELIVERY_STATES.map((state) => ({ state, count: counts.get(state) ?? 0 }));
+        return {
+            bars,
+            total: bars.reduce((sum, bar) => sum + bar.count, 0),
+            isLowerBound: model.omissions.messageGroups > 0 ||
+                model.omissions.upstreamMessageEvents > 0,
+        };
+    }
+    Embassy.pulse = pulse;
+    function isMonitorOnly(route) {
+        return route.safeErrorCode === "CODEX_WRITES_DISABLED";
+    }
+    Embassy.isMonitorOnly = isMonitorOnly;
+    function hasLifecycleTruncation(group) {
+        for (let index = 1; index < group.events.length; index += 1) {
+            const previous = group.events[index - 1];
+            const current = group.events[index];
+            if (previous !== undefined &&
+                current !== undefined &&
+                current.sequence > previous.sequence + 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+    Embassy.hasLifecycleTruncation = hasLifecycleTruncation;
+    function deliveriesTruncated(model) {
+        return (model.omissions.messageEvents > 0 ||
+            model.activity.some(hasLifecycleTruncation));
+    }
+    Embassy.deliveriesTruncated = deliveriesTruncated;
+    function deliveryGroupKey(group) {
+        const suffix = group.messageIdSuffix ?? `seq${group.events[0]?.sequence ?? 0}`;
+        return `${group.direction}|${group.sourceAlias}|${group.targetAlias}|${suffix}`;
+    }
+    Embassy.deliveryGroupKey = deliveryGroupKey;
+    const GUIDANCE_COPY_KEYS = {
+        reobserve_claude: "reobserveClaude",
+        reobserve_codex: "reobserveCodex",
+        claude_not_observed: "claudeNotObserved",
+        codex_stale: "codexStale",
+        connector_offline: "connectorOffline",
+        route_stale: "routeStale",
+        queue_stalled: "queueStalled",
+        unconfirmed: "unconfirmed",
+        degraded: "degraded",
+        codex_succession_busy: "codexSuccessionBusy",
+        codex_succession_recovery: "codexSuccessionRecovery",
+        progress_watch: "progressWatch",
+        generic: "generic",
+    };
+    function guidanceCopyKey(guidance) {
+        return GUIDANCE_COPY_KEYS[guidance];
+    }
+    Embassy.guidanceCopyKey = guidanceCopyKey;
+    function attentionCommand(item) {
+        switch (item.guidance) {
+            case "reobserve_claude":
+            case "claude_not_observed":
+                return `embassy select-claude --alias ${item.alias ?? "<alias>"}`;
+            case "reobserve_codex":
+            case "codex_stale":
+                return `embassy register-codex --alias ${item.alias ?? "<alias>"}`;
+            case "codex_succession_busy":
+            case "codex_succession_recovery":
+                return `embassy register-codex --alias <new> --succeeds ${item.alias ?? "<old>"}`;
+            default:
+                return "embassy status";
+        }
+    }
+    Embassy.attentionCommand = attentionCommand;
+    function attentionViews(model) {
+        return model.attention.map((item) => ({
+            item,
+            guidanceKey: guidanceCopyKey(item.guidance),
+            command: attentionCommand(item),
+        }));
+    }
+    Embassy.attentionViews = attentionViews;
+    function extractSuccessions(model) {
+        const successions = [];
+        for (const item of model.attention) {
+            if (item.guidance === "codex_succession_busy") {
+                successions.push({
+                    item,
+                    guidanceKey: "codexSuccessionBusy",
+                    command: attentionCommand(item),
+                });
+            }
+            else if (item.guidance === "codex_succession_recovery") {
+                successions.push({
+                    item,
+                    guidanceKey: "codexSuccessionRecovery",
+                    command: attentionCommand(item),
+                });
+            }
+        }
+        return successions;
+    }
+    Embassy.extractSuccessions = extractSuccessions;
+    function overviewProps(model, nowMs) {
+        return {
+            generatedAt: model.generatedAt,
+            inboundMode: model.inboundMode,
+            overall: model.overall,
+            statusStrip: {
+                broker: model.health,
+                claudeConnector: worstConnectorHealth(model, "claude"),
+                codexConnector: worstConnectorHealth(model, "codex"),
+                compatibility: worstCompatibility(model),
+            },
+            exchange: {
+                ...model.exchange,
+                codex: {
+                    ...model.exchange.codex,
+                    monitorOnly: model.routes.filter((route) => route.provider === "codex" && isMonitorOnly(route)).length,
+                },
+            },
+            queueClaudeToCodex: queueSplit(model, "codex", nowMs),
+            queueCodexToClaude: queueSplit(model, "claude", nowMs),
+            graph: model.graph,
+            attention: attentionViews(model),
+            attentionOmitted: model.omissions.attentionItems,
+            pulse: pulse(model),
+        };
+    }
+    Embassy.overviewProps = overviewProps;
+    function deliveriesGroups(model) {
+        return model.activity.map((group) => ({
+            key: deliveryGroupKey(group),
+            group,
+            routePair: `${group.sourceAlias} → ${group.targetAlias}`,
+            eventsTruncated: hasLifecycleTruncation(group),
+        }));
+    }
+    Embassy.deliveriesGroups = deliveriesGroups;
+    function routesProps(model, nowMs) {
+        const codexRoutes = model.routes
+            .filter((route) => route.provider === "codex")
+            .map((route) => ({
+            route,
+            monitorOnly: isMonitorOnly(route),
+            oldestAgeMs: routeOldestAgeMs(route, nowMs),
+        }));
+        return {
+            inboundMode: model.inboundMode,
+            peers: model.peers,
+            peersOmitted: model.omissions.availablePeers,
+            codexRoutes,
+            routesOmitted: model.omissions.routes,
+            pairs: model.pairs,
+            pairsOmitted: model.omissions.pairs,
+            graph: model.graph,
+            successions: extractSuccessions(model),
+        };
+    }
+    Embassy.routesProps = routesProps;
+    function activityRowSource(row) {
+        if (row.kind === "delivery")
+            return row.group.sourceAlias;
+        if (row.kind === "operation")
+            return row.event.aliases[0] ?? "";
+        return row.item.alias ?? row.item.host ?? "";
+    }
+    function activityRows(model) {
+        const rows = [];
+        for (const group of model.activity) {
+            if (!isTerminalDeliveryState(group.state))
+                continue;
+            rows.push({ kind: "delivery", timestamp: group.timestamp, group });
+        }
+        for (const item of model.attention) {
+            if (item.timestamp === undefined)
+                continue;
+            rows.push({
+                kind: "alert",
+                timestamp: item.timestamp,
+                item,
+                guidanceKey: guidanceCopyKey(item.guidance),
+            });
+        }
+        for (const event of model.brokerActivity ?? []) {
+            rows.push({ kind: "operation", timestamp: event.timestamp, event });
+        }
+        return rows.sort((left, right) => compareText(right.timestamp ?? "", left.timestamp ?? "") ||
+            compareText(activityRowSource(left), activityRowSource(right)));
+    }
+    Embassy.activityRows = activityRows;
+    function diagnosticsProps(model) {
+        return {
+            connectors: model.connectors,
+            connectorsOmitted: model.omissions.connectors,
+            compatibilityChecks: model.compatibilityChecks ?? [],
+            expiredCount: model.accounting.expired,
+            ...(model.deadlinePressure === undefined
+                ? {}
+                : { deadlinePressure: model.deadlinePressure }),
+            queuedMessages: model.exchange.queuedMessages,
+            queueCountIsLowerBound: model.exchange.queueCountIsLowerBound,
+            accounting: model.accounting,
+            omissions: model.omissions,
+        };
+    }
+    Embassy.diagnosticsProps = diagnosticsProps;
+    Embassy.adapter = {
+        overviewProps,
+        deliveriesGroups,
+        routesProps,
+        activityRows,
+        diagnosticsProps,
+        queueSplit,
+        routeOldestAgeMs,
+        pulse,
+        worstConnectorHealth,
+        worstCompatibility,
+        extractSuccessions,
+        isMonitorOnly,
+        hasLifecycleTruncation,
+        deliveriesTruncated,
+        deliveryGroupKey,
+        guidanceCopyKey,
+        attentionCommand,
+        attentionViews,
+        isTerminalDeliveryState,
+        parseTimestampMs,
+    };
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const HEARTBEAT_WATCHDOG_MS = 35_000;
+    const AUTO_RECONNECT_DELAY_MS = 5_000;
+    const MAX_AUTO_RECONNECT_ATTEMPTS = 3;
+    const MAX_STREAM_BUFFER_LENGTH = 1_048_576;
+    function createProtocol(options) {
+        const base = location.pathname.endsWith("/bootstrap")
+            ? location.pathname.slice(0, -10)
+            : location.pathname.endsWith("/")
+                ? location.pathname.slice(0, -1)
+                : location.pathname;
+        const api = (name) => base + "/" + name;
+        let connectionState = "connecting";
+        let controller;
+        let watchdogTimer;
+        let reconnectTimer;
+        let reconnectAttempts = 0;
+        let lastStreamRevision;
+        let gapRecoveryInFlight = false;
+        function apiFetch(name, fetchOptions = {}) {
+            const init = {
+                method: "POST",
+                credentials: "same-origin",
+                cache: "no-store",
+                headers: { "X-Embassy-Request": "1", ...(fetchOptions.headers ?? {}) },
+            };
+            if (fetchOptions.body !== undefined) {
+                init.body = fetchOptions.body;
+            }
+            if (fetchOptions.signal !== undefined) {
+                init.signal = fetchOptions.signal;
+            }
+            return fetch(api(name), init);
+        }
+        function notify(kind) {
+            options.onNotice?.(kind);
+        }
+        function setConnectionState(next) {
+            connectionState = next;
+            if (next === "connected") {
+                reconnectAttempts = 0;
+            }
+            options.onConnectionState(next);
+            if (next === "disconnected") {
+                scheduleAutoReconnect();
+            }
+        }
+        function clearWatchdog() {
+            if (watchdogTimer !== undefined) {
+                window.clearTimeout(watchdogTimer);
+                watchdogTimer = undefined;
+            }
+        }
+        function armWatchdog(current) {
+            clearWatchdog();
+            watchdogTimer = window.setTimeout(() => {
+                watchdogTimer = undefined;
+                if (connectionState !== "connected" || controller !== current) {
+                    return;
+                }
+                current.abort();
+                setConnectionState("disconnected");
+            }, HEARTBEAT_WATCHDOG_MS);
+        }
+        function clearReconnectTimer() {
+            if (reconnectTimer !== undefined) {
+                window.clearTimeout(reconnectTimer);
+                reconnectTimer = undefined;
+            }
+        }
+        function scheduleAutoReconnect() {
+            if (reconnectTimer !== undefined || reconnectAttempts >= MAX_AUTO_RECONNECT_ATTEMPTS) {
+                return;
+            }
+            reconnectTimer = window.setTimeout(() => {
+                reconnectTimer = undefined;
+                if (connectionState !== "disconnected") {
+                    return;
+                }
+                reconnectAttempts += 1;
+                void connect();
+            }, AUTO_RECONNECT_DELAY_MS);
+        }
+        function ingest(event, source) {
+            const previous = lastStreamRevision;
+            const gap = previous !== undefined && event.streamRevision > previous + 1;
+            lastStreamRevision = event.streamRevision;
+            options.onEvent(event);
+            if (event.reset) {
+                notify("reset");
+            }
+            if (gap) {
+                notify("missedFrames");
+                if (source === "stream" && !gapRecoveryInFlight) {
+                    gapRecoveryInFlight = true;
+                    void fetchSnapshotNow().finally(() => {
+                        gapRecoveryInFlight = false;
+                    });
+                }
+            }
+        }
+        async function exchangeCapability() {
+            const capability = location.hash.slice(1);
+            if (!capability) {
+                return;
+            }
+            history.replaceState(null, "", location.pathname);
+            const response = await apiFetch("session", {
+                headers: { "Content-Type": "text/plain;charset=UTF-8" },
+                body: capability,
+            });
+            if (!response.ok) {
+                throw new Error("session");
+            }
+        }
+        function consumeSseBlock(block) {
+            let event = "message";
+            const data = [];
+            for (const line of block.split("\n")) {
+                if (line.startsWith("event:")) {
+                    event = line.slice(6).trim();
+                }
+                if (line.startsWith("data:")) {
+                    data.push(line.slice(5).trimStart());
+                }
+            }
+            if (event === "snapshot" && data.length > 0) {
+                const parsed = JSON.parse(data.join("\n"));
+                setConnectionState("connected");
+                ingest(parsed, "stream");
+            }
+            else if (event === "observer_unavailable") {
+                setConnectionState("unavailable");
+            }
+            else if (event === "shutdown") {
+                setConnectionState("stopped");
+            }
+        }
+        async function connect() {
+            if (controller) {
+                controller.abort();
+            }
+            const current = new AbortController();
+            controller = current;
+            setConnectionState("connecting");
+            try {
+                const response = await apiFetch("stream", { signal: current.signal });
+                if (!response.ok || !response.body) {
+                    throw new Error("stream");
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                armWatchdog(current);
+                while (true) {
+                    const result = await reader.read();
+                    if (result.done) {
+                        break;
+                    }
+                    armWatchdog(current);
+                    buffer += decoder.decode(result.value, { stream: true }).replaceAll("\r\n", "\n");
+                    if (buffer.length > MAX_STREAM_BUFFER_LENGTH) {
+                        throw new Error("frame");
+                    }
+                    let boundary;
+                    while ((boundary = buffer.indexOf("\n\n")) >= 0) {
+                        consumeSseBlock(buffer.slice(0, boundary));
+                        buffer = buffer.slice(boundary + 2);
+                    }
+                }
+                if (!current.signal.aborted && connectionState !== "stopped") {
+                    setConnectionState("disconnected");
+                }
+            }
+            catch {
+                if (!current.signal.aborted) {
+                    setConnectionState("disconnected");
+                }
+            }
+            finally {
+                clearWatchdog();
+            }
+        }
+        async function fetchSnapshotNow() {
+            try {
+                const response = await apiFetch("snapshot");
+                if (response.ok) {
+                    const event = (await response.json());
+                    ingest(event, "snapshot");
+                }
+                else {
+                    setConnectionState(connectionState === "connected" ? "unavailable" : "disconnected");
+                }
+            }
+            catch {
+                setConnectionState(connectionState === "connected" ? "unavailable" : "disconnected");
+            }
+        }
+        function isActionResult(value) {
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                return false;
+            }
+            const record = value;
+            return (Object.keys(record).length === 2 &&
+                typeof record.ok === "boolean" &&
+                typeof record.code === "string" &&
+                /^(?:ok|not_found|conflict|route_mismatch|busy|unavailable|rejected|rate_limited)$/u.test(record.code) &&
+                ((record.ok && record.code === "ok") ||
+                    (!record.ok && record.code !== "ok")));
+        }
+        async function executeAction(action) {
+            let result = {
+                ok: false,
+                code: "unavailable",
+            };
+            try {
+                const response = await apiFetch("action", {
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(action),
+                });
+                const parsed = await response.json();
+                if (isActionResult(parsed))
+                    result = parsed;
+            }
+            catch {
+            }
+            await fetchSnapshotNow();
+            return result;
+        }
+        async function start() {
+            try {
+                await exchangeCapability();
+            }
+            catch {
+                setConnectionState("disconnected");
+                return;
+            }
+            await connect();
+        }
+        return {
+            start: () => {
+                void start();
+            },
+            pause: () => {
+                clearReconnectTimer();
+                if (controller) {
+                    controller.abort();
+                }
+                setConnectionState("paused");
+            },
+            reconnect: () => {
+                clearReconnectTimer();
+                reconnectAttempts = 0;
+                void connect();
+            },
+            readNow: () => {
+                void fetchSnapshotNow();
+            },
+            executeAction,
+        };
+    }
+    Embassy.createProtocol = createProtocol;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    function StateChip(props) {
+        const t = Embassy.useT();
+        const domain = props.domain ?? "delivery";
+        const kind = domain === "delivery"
+            ? Embassy.chipKindFor(props.state, props.direction, props.safeErrorCode)
+            : Embassy.chipKindByDomain(domain, props.state, props.direction);
+        const meaning = props.note ??
+            t(Embassy.meaningKeyFor(domain, props.state, props.safeErrorCode, props.direction));
+        return (React.createElement("span", { className: props.small === true ? "chip chip--small" : "chip", "data-kind": kind, title: meaning, "aria-description": meaning }, props.label ?? props.state));
+    }
+    Embassy.StateChip = StateChip;
+    function MonoLabel(props) {
+        const className = props.className === undefined
+            ? "mono-label"
+            : `mono-label ${props.className}`;
+        return React.createElement("div", { className: className }, props.children);
+    }
+    Embassy.MonoLabel = MonoLabel;
+    function CopyCmd(props) {
+        const t = Embassy.useT();
+        const [feedback, setFeedback] = React.useState("idle");
+        React.useEffect(() => {
+            if (feedback === "idle")
+                return undefined;
+            const handle = window.setTimeout(() => {
+                setFeedback("idle");
+            }, 1_500);
+            return () => {
+                window.clearTimeout(handle);
+            };
+        }, [feedback]);
+        const copy = () => {
+            const clipboard = navigator.clipboard;
+            if (clipboard === undefined) {
+                setFeedback("failed");
+                return;
+            }
+            clipboard.writeText(props.cmd).then(() => {
+                setFeedback("copied");
+            }, () => {
+                setFeedback("failed");
+            });
+        };
+        const status = feedback === "copied"
+            ? t("app.copied")
+            : feedback === "failed"
+                ? t("app.copyFailed")
+                : "";
+        return (React.createElement("div", { className: "copy-cmd" },
+            React.createElement("code", { className: "copy-cmd__code" }, props.cmd),
+            React.createElement("span", { className: "copy-cmd__status", "data-tone": feedback === "failed" ? "error" : undefined, "aria-live": "polite" }, status),
+            React.createElement("button", { type: "button", className: "copy-cmd__button", onClick: copy }, t("app.copy"))));
+    }
+    Embassy.CopyCmd = CopyCmd;
+    function Rule(props) {
+        const className = props.className === undefined ? "rule" : `rule ${props.className}`;
+        return React.createElement("hr", { className: className });
+    }
+    Embassy.Rule = Rule;
+    function FilterPill(props) {
+        return (React.createElement("button", { type: "button", className: "pill", "aria-pressed": props.active, onClick: props.onClick }, props.children));
+    }
+    Embassy.FilterPill = FilterPill;
+    function TimeAgo(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        const nowMs = Embassy.useNowMs();
+        const absolute = Embassy.fmtAbs(props.iso, locale);
+        const parsedMs = Date.parse(props.iso);
+        const ageMs = Number.isFinite(parsedMs) ? nowMs - parsedMs : undefined;
+        const relative = ageMs !== undefined && ageMs >= 3_600_000
+            ? t("time.ago", { duration: Embassy.fmtAge(ageMs) })
+            : Embassy.fmtRel(props.iso, nowMs, locale);
+        return (React.createElement("span", { className: "time-ago", title: absolute },
+            relative,
+            React.createElement("span", { className: "sr-only" },
+                " (",
+                absolute,
+                ")")));
+    }
+    Embassy.TimeAgo = TimeAgo;
+    function Tooltip(props) {
+        const descriptionId = React.useId();
+        return (React.createElement("span", { className: "tooltip", tabIndex: 0, "data-tip": props.tip, "data-tip-wrap": props.wrap === true ? "" : undefined, "aria-describedby": descriptionId },
+            props.children ?? React.createElement("span", { className: "info-dot" }, "i"),
+            React.createElement("span", { className: "sr-only", id: descriptionId }, props.tip)));
+    }
+    Embassy.Tooltip = Tooltip;
+    function AbsentFeature(props) {
+        const t = Embassy.useT();
+        return (React.createElement("section", { className: "absent-feature" },
+            React.createElement(MonoLabel, null, t("app.notLanded.title")),
+            React.createElement("h3", { className: "absent-feature__title" }, props.title),
+            React.createElement("p", { className: "absent-feature__body" }, props.body),
+            React.createElement("p", { className: "absent-feature__note" }, t("app.notLanded.body")),
+            props.cmd === undefined ? null : React.createElement(CopyCmd, { cmd: props.cmd })));
+    }
+    Embassy.AbsentFeature = AbsentFeature;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const PULSE_BAR_BASE_PX = 6;
+    const PULSE_BAR_RANGE_PX = 38;
+    const QUEUE_DEPTH_COMMAND = "EMBASSY_MAX_QUEUE_MESSAGES=<n> embassy serve";
+    const NEXT_ACTION_COPY_KEYS = {
+        discover_claude: "next.discoverClaude",
+        select_claude: "next.selectClaude",
+        pair_routes: "next.pairRoutes",
+        restore_claude: "next.restoreClaude",
+        repair_claude_inventory: "next.repairClaude",
+        register_codex: "next.registerCodex",
+        restore_codex: "next.restoreCodex",
+        none: "next.none",
+    };
+    function LowerBound(props) {
+        const t = Embassy.useT();
+        const sentence = t("app.lowerBound", { count: props.count });
+        return (React.createElement("span", { className: "lower-bound", title: sentence },
+            React.createElement("span", { "aria-hidden": "true" }, t("count.atLeast", { count: props.count })),
+            React.createElement("span", { className: "sr-only" }, sentence)));
+    }
+    function StatusCard(props) {
+        return (React.createElement("div", { className: "status-card" },
+            React.createElement("div", { className: "status-card__head" },
+                React.createElement("span", { className: "status-card__label" }, props.label),
+                props.chip),
+            props.detail === undefined ? null : (React.createElement("span", { className: "status-card__detail" }, props.detail))));
+    }
+    function HealthStatusCard(props) {
+        const t = Embassy.useT();
+        const health = props.health;
+        if (health === undefined) {
+            return (React.createElement(StatusCard, { label: props.label, detail: undefined, chip: React.createElement("span", { className: "chip chip--small", "data-kind": "inert" }, t("app.overview.connectorMissing")) }));
+        }
+        return (React.createElement(StatusCard, { label: props.label, detail: t(`health.meaning.${Embassy.camelCaseToken(health)}`), chip: React.createElement(Embassy.StateChip, { domain: "health", state: health, small: true }) }));
+    }
+    function CompatStatusCard(props) {
+        const t = Embassy.useT();
+        const compatibility = props.compatibility;
+        if (compatibility === undefined) {
+            return (React.createElement(StatusCard, { label: t("app.overview.compat"), detail: undefined, chip: React.createElement("span", { className: "chip chip--small", "data-kind": "inert" }, t("app.overview.connectorMissing")) }));
+        }
+        return (React.createElement(StatusCard, { label: t("app.overview.compat"), detail: t(`compatibility.meaning.${Embassy.camelCaseToken(compatibility)}`), chip: React.createElement(Embassy.StateChip, { domain: "compatibility", state: compatibility, small: true }) }));
+    }
+    function ExchangeNode(props) {
+        const party = props.party;
+        return (React.createElement("div", { className: "exchange-node" },
+            React.createElement("div", null,
+                React.createElement("div", { className: "exchange-node__title" }, props.title),
+                React.createElement("div", { className: "exchange-node__sub" }, props.sub)),
+            React.createElement("div", { className: "chip-row" },
+                React.createElement(Embassy.StateChip, { domain: "party", state: party.status, small: true }),
+                party.countIsLowerBound ? React.createElement(LowerBound, { count: party.total }) : null),
+            React.createElement("div", { className: "exchange-node__line" }, props.countLine),
+            party.primaryAlias === undefined ? null : (React.createElement("div", { className: "exchange-node__line mono" }, party.primaryAlias))));
+    }
+    function liveQueueAgeMs(queue, nowMs) {
+        const queuedMs = Embassy.parseTimestampMs(queue.oldestQueuedAt);
+        if (queuedMs === undefined)
+            return queue.oldestAgeMs;
+        return Math.max(0, nowMs - queuedMs);
+    }
+    function ExchangeEdge(props) {
+        const t = Embassy.useT();
+        const nowMs = Embassy.useNowMs();
+        const queue = props.queue;
+        const inbound = props.direction === "in";
+        const ageMs = liveQueueAgeMs(queue, nowMs);
+        const oldest = queue.depth > 0 && ageMs !== undefined
+            ? ` · ${t("app.overview.oldest")} ${Embassy.fmtAge(ageMs)}`
+            : "";
+        return (React.createElement("div", { className: "exchange-edge" },
+            React.createElement("div", { className: "edge-label" }, props.label),
+            React.createElement("div", { className: "edge-line" },
+                React.createElement("span", { className: inbound ? "edge-arrow edge-arrow--in" : "edge-arrow edge-arrow--out", "aria-hidden": "true" }, inbound ? "←" : "→")),
+            React.createElement("div", { className: "edge-queue", "data-active": queue.depth > 0 ? "true" : "false" }, `${t("app.overview.depth")} ${queue.depth}${oldest}`),
+            queue.depthIsLowerBound ? React.createElement(LowerBound, { count: queue.depth }) : null));
+    }
+    function attentionScopeParts(item, t) {
+        const parts = [];
+        if (item.provider !== undefined) {
+            parts.push(item.provider === "claude" ? t("provider.claude") : t("provider.codex"));
+        }
+        if (item.alias !== undefined)
+            parts.push(item.alias);
+        if (item.host !== undefined)
+            parts.push(item.host);
+        if (item.code !== undefined)
+            parts.push(item.code);
+        return parts;
+    }
+    function AttentionItem(props) {
+        const t = Embassy.useT();
+        const { item, guidanceKey, command } = props.view;
+        const scope = attentionScopeParts(item, t).join(" · ");
+        return (React.createElement("div", { className: "attention-item" },
+            React.createElement("div", { className: "attention-item__head" },
+                React.createElement(Embassy.StateChip, { domain: "severity", state: item.severity, small: true }),
+                React.createElement("h3", { className: "attention-item__title" }, t(`guidance.${guidanceKey}.title`)),
+                item.timestamp === undefined ? null : (React.createElement(Embassy.TimeAgo, { iso: item.timestamp }))),
+            React.createElement("p", { className: "attention-item__body" }, t(`guidance.${guidanceKey}.body`)),
+            React.createElement("p", { className: "attention-item__body" }, t(`guidance.${guidanceKey}.action`)),
+            scope === "" ? null : (React.createElement("div", { className: "attention-item__scope" }, `${t("attention.scope")}: ${scope}`)),
+            React.createElement("div", { className: "attention-item__action" },
+                React.createElement(Embassy.CopyCmd, { cmd: command })),
+            item.guidance === "queue_stalled" ? (React.createElement(Embassy.AbsentFeature, { title: t("app.diag.queue.title"), body: t("app.diag.editable.note"), cmd: QUEUE_DEPTH_COMMAND })) : null));
+    }
+    function PulseBarButton(props) {
+        const t = Embassy.useT();
+        const { bar } = props;
+        const viewIn = t("app.overview.viewIn");
+        const heightPx = PULSE_BAR_BASE_PX + (PULSE_BAR_RANGE_PX * bar.count) / props.maxCount;
+        return (React.createElement("button", { type: "button", className: "pulse-bar-btn", title: viewIn, "aria-label": `${bar.state}: ${bar.count} — ${viewIn}`, onClick: () => {
+                props.onSelect(bar.state);
+            } },
+            React.createElement("span", { className: "pulse-count" }, bar.count),
+            React.createElement("span", { className: "pulse-bar", "data-kind": Embassy.chipKindFor(bar.state), "data-empty": bar.count === 0 ? "true" : "false", style: { height: `${heightPx}px` } }),
+            React.createElement(Embassy.StateChip, { state: bar.state, small: true })));
+    }
+    function OverviewTab(props) {
+        const t = Embassy.useT();
+        const { data, onViewDeliveries } = props;
+        const strip = data.statusStrip;
+        const queueOut = data.queueClaudeToCodex;
+        const queueIn = data.queueCodexToClaude;
+        const openInbound = data.inboundMode === "open";
+        const showEdges = data.graph.readyPairCount > 0 || queueOut.depth > 0 || queueIn.depth > 0;
+        const nextActionLine = (who, action) => action === "none"
+            ? null
+            : `${t("next.label")} · ${who}: ${t(NEXT_ACTION_COPY_KEYS[action])}`;
+        const boardNotes = [
+            !openInbound && showEdges && data.graph.readyPairCount === 0
+                ? `${t("app.overview.noPair.title")} — ${t("app.overview.noPair.body")}`
+                : null,
+            nextActionLine(t("provider.claude"), data.exchange.claude.nextAction),
+            nextActionLine(t("provider.codex"), data.exchange.codex.nextAction),
+        ].filter((line) => line !== null);
+        const showAttention = data.attention.length > 0 || data.attentionOmitted > 0;
+        const maxPulse = data.pulse.bars.reduce((largest, bar) => Math.max(largest, bar.count), 1);
+        const selectPulseState = React.useCallback((state) => {
+            onViewDeliveries({ state });
+        }, [onViewDeliveries]);
+        const idPrefix = React.useId();
+        const stripId = `${idPrefix}-strip`;
+        const exchangeId = `${idPrefix}-exchange`;
+        const attentionId = `${idPrefix}-attention`;
+        const pulseId = `${idPrefix}-pulse`;
+        return (React.createElement("div", { className: "tab-panel" },
+            React.createElement("section", { className: "section", "aria-labelledby": stripId },
+                React.createElement("h2", { className: "mono-label section-label", id: stripId }, t("app.overview.statusStrip")),
+                React.createElement("div", { className: "status-strip" },
+                    React.createElement(HealthStatusCard, { label: t("app.overview.broker"), health: strip.broker }),
+                    React.createElement(HealthStatusCard, { label: t("app.overview.claudeConn"), health: strip.claudeConnector }),
+                    React.createElement(HealthStatusCard, { label: t("app.overview.codexConn"), health: strip.codexConnector }),
+                    React.createElement(CompatStatusCard, { compatibility: strip.compatibility }))),
+            React.createElement("section", { className: "section", "aria-labelledby": exchangeId },
+                React.createElement("div", { className: "row section-label section-head" },
+                    React.createElement("h2", { className: "mono-label", id: exchangeId }, t("exchange.eyebrow")),
+                    React.createElement(Embassy.Tooltip, { tip: t("exchange.note"), wrap: true },
+                        React.createElement("span", { className: "info-dot" }, "i"))),
+                React.createElement("div", { className: "inbound-policy", "data-inbound-mode": data.inboundMode },
+                    React.createElement("span", { className: "chip chip--small", "data-kind": openInbound ? "warning" : "inert" }, t(openInbound
+                        ? "inbound.open.badge"
+                        : "inbound.paired.badge")),
+                    React.createElement("p", null, t(openInbound
+                        ? "inbound.open.body"
+                        : data.graph.readyPairCount > 0
+                            ? "inbound.paired.body"
+                            : "inbound.noPair.body"))),
+                React.createElement("div", { className: "exchange-board" },
+                    React.createElement(ExchangeNode, { title: t("app.overview.node.claude.title"), sub: t("app.overview.node.claude.sub"), party: data.exchange.claude, countLine: t("exchange.count.claude", {
+                            ready: data.exchange.claude.ready,
+                            selectable: data.exchange.claude.selectable ?? "—",
+                            total: data.exchange.claude.total,
+                        }) }),
+                    showEdges ? (React.createElement("div", { className: "exchange-edges" },
+                        React.createElement(ExchangeEdge, { direction: "out", label: t("app.overview.queueC2x"), queue: queueOut }),
+                        React.createElement(ExchangeEdge, { direction: "in", label: t("app.overview.queueX2c"), queue: queueIn }))) : (React.createElement("div", { className: "no-pair" },
+                        React.createElement("span", { className: "no-pair__label" }, t(openInbound
+                            ? "inbound.open.badge"
+                            : "app.overview.noPair.title")),
+                        React.createElement("span", { className: "no-pair__body" }, t(openInbound
+                            ? "inbound.open.body"
+                            : "app.overview.noPair.body")))),
+                    React.createElement(ExchangeNode, { title: t("app.overview.node.codex.title"), sub: t("app.overview.node.codex.sub"), party: data.exchange.codex, countLine: t("app.overview.count.codex", {
+                            ready: data.exchange.codex.ready,
+                            total: data.exchange.codex.total,
+                            monitorOnly: data.exchange.codex.monitorOnly ?? 0,
+                        }) })),
+                boardNotes.length === 0 ? null : (React.createElement("div", { className: "exchange-notes stack-sm" }, boardNotes.map((line) => (React.createElement("p", { className: "text-xs text-body-muted", key: line }, line)))))),
+            showAttention ? (React.createElement("section", { className: "section", "aria-labelledby": attentionId },
+                React.createElement("div", { className: "row section-label section-head" },
+                    React.createElement("h2", { className: "mono-label", id: attentionId }, t("attention.eyebrow")),
+                    data.attentionOmitted > 0 ? (React.createElement(LowerBound, { count: data.attention.length })) : null),
+                React.createElement("div", { className: "attention-list" }, data.attention.map((view, index) => (React.createElement(AttentionItem, { key: `${view.item.kind}|${view.item.guidance}|${view.item.alias ?? ""}|${view.item.host ?? ""}|${index}`, view: view })))),
+                data.attentionOmitted > 0 ? (React.createElement("p", { className: "footnote" }, t("attention.projectionOnly"))) : null)) : null,
+            React.createElement("section", { className: "section", "aria-labelledby": pulseId },
+                React.createElement("h2", { className: "mono-label section-label", id: pulseId }, t("app.overview.pulse.title")),
+                data.pulse.total === 0 ? (React.createElement("p", { className: "pulse-empty" }, t("app.overview.pulse.empty"))) : null,
+                React.createElement("div", { className: "pulse" }, data.pulse.bars.map((bar) => (React.createElement(PulseBarButton, { key: bar.state, bar: bar, maxCount: maxPulse, onSelect: selectPulseState })))),
+                React.createElement("p", { className: "pulse-caption" },
+                    t("app.overview.pulse.caption"),
+                    data.pulse.isLowerBound ? " " : null,
+                    data.pulse.isLowerBound ? (React.createElement(LowerBound, { count: data.pulse.total })) : null))));
+    }
+    Embassy.OverviewTab = OverviewTab;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const DELIVERY_STATE_FILTERS = [
+        "queued",
+        "dispatching",
+        "transport_written",
+        "held",
+        "duplicate",
+        "delivered",
+        "unconfirmed",
+        "ambiguous",
+        "failed",
+        "expired",
+        "rejected",
+        "cancelled",
+        "abandoned",
+    ];
+    const DELIVERY_STATE_FILTERS_COVER_THE_UNION = true;
+    const DIRECTION_FILTERS = [
+        "claude_to_codex",
+        "codex_to_claude",
+    ];
+    const DIRECTION_COPY_KEYS = {
+        claude_to_codex: "direction.claudeToCodex",
+        codex_to_claude: "direction.codexToClaude",
+    };
+    const DIRECTION_PILL_COPY_KEYS = {
+        claude_to_codex: "direction.claudeToCodex",
+        codex_to_claude: "app.deliveries.dir.codexToClaude",
+    };
+    const SEND_TO_CODEX_CMD = "embassy send-to-codex --from <alias> --to <alias>";
+    const countFormatters = new Map();
+    function fmtCount(locale, value) {
+        const existing = countFormatters.get(locale);
+        if (existing !== undefined)
+            return existing.format(value);
+        const formatter = new Intl.NumberFormat(locale);
+        countFormatters.set(locale, formatter);
+        return formatter.format(value);
+    }
+    function includesFold(haystack, needleLower) {
+        return haystack !== undefined && haystack.toLowerCase().includes(needleLower);
+    }
+    function equalsFold(value, wantedLower) {
+        return value !== undefined && value.toLowerCase() === wantedLower;
+    }
+    function matchesQuery(view, needleLower) {
+        if (needleLower === "")
+            return true;
+        const group = view.group;
+        return (includesFold(group.messageIdSuffix, needleLower) ||
+            includesFold(group.conversationIdSuffix, needleLower) ||
+            includesFold(group.sourceAlias, needleLower) ||
+            includesFold(group.targetAlias, needleLower) ||
+            includesFold(group.safeErrorCode, needleLower) ||
+            group.events.some((event) => includesFold(event.safeErrorCode, needleLower)));
+    }
+    function findPresetTarget(groups, token) {
+        const wanted = token.trim().toLowerCase();
+        if (wanted === "")
+            return undefined;
+        const bySuffix = groups.find((view) => equalsFold(view.group.messageIdSuffix, wanted) ||
+            equalsFold(view.group.conversationIdSuffix, wanted));
+        if (bySuffix !== undefined)
+            return bySuffix;
+        return groups.find((view) => equalsFold(view.group.safeErrorCode, wanted) ||
+            view.group.events.some((event) => equalsFold(event.safeErrorCode, wanted)));
+    }
+    function groupByRoutePair(views) {
+        const order = [];
+        const buckets = new Map();
+        for (const view of views) {
+            const bucket = buckets.get(view.routePair);
+            if (bucket === undefined) {
+                buckets.set(view.routePair, [view]);
+                order.push(view.routePair);
+            }
+            else {
+                bucket.push(view);
+            }
+        }
+        return order.map((pair) => ({ pair, rows: buckets.get(pair) ?? [] }));
+    }
+    function droppedEventCount(group) {
+        let dropped = 0;
+        for (let index = 1; index < group.events.length; index += 1) {
+            const previous = group.events[index - 1];
+            const current = group.events[index];
+            if (previous === undefined || current === undefined)
+                continue;
+            const gap = current.sequence - previous.sequence - 1;
+            if (gap > 0)
+                dropped += gap;
+        }
+        return dropped;
+    }
+    function DetailRow(props) {
+        return (React.createElement("div", { className: "detail-row" },
+            React.createElement("span", { className: "detail-label" }, props.label),
+            " ",
+            React.createElement("span", { className: props.mono === true
+                    ? "detail-value detail-value--mono"
+                    : "detail-value" }, props.children)));
+    }
+    function DeliveryLifecycle(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        const events = props.group.events;
+        return (React.createElement("div", { className: "lifecycle" }, events.map((event, index) => {
+            const isLast = index === events.length - 1;
+            const kind = Embassy.chipKindFor(event.state, props.group.direction, event.safeErrorCode);
+            const noteParts = [];
+            if (event.safeErrorCode !== undefined) {
+                noteParts.push(event.safeErrorCode);
+            }
+            if (event.latencyMs !== undefined) {
+                noteParts.push(`${fmtCount(locale, event.latencyMs)} ms`);
+            }
+            return (React.createElement("div", { className: "lifecycle-item", key: event.sequence },
+                React.createElement("div", { className: "lifecycle-rail", "aria-hidden": true },
+                    React.createElement("span", { className: "lifecycle-dot", "data-kind": isLast ? kind : undefined }),
+                    isLast ? null : React.createElement("span", { className: "lifecycle-connector" })),
+                React.createElement("div", { className: "lifecycle-body" },
+                    React.createElement("div", { className: "lifecycle-head" },
+                        React.createElement(Embassy.StateChip, { small: true, state: event.state, direction: props.group.direction, safeErrorCode: event.safeErrorCode }),
+                        event.timestamp === undefined ? (React.createElement("span", { className: "lifecycle-abs" }, t("time.unavailable"))) : (React.createElement(React.Fragment, null,
+                            React.createElement(Embassy.TimeAgo, { iso: event.timestamp }),
+                            React.createElement("span", { className: "lifecycle-abs" }, Embassy.fmtAbs(event.timestamp, locale))))),
+                    noteParts.length === 0 ? null : (React.createElement("div", { className: "lifecycle-note" }, noteParts.join(" · "))),
+                    React.createElement("div", { className: "lifecycle-meaning" }, t(Embassy.deliveryMeaningKey(event.state, event.safeErrorCode, props.group.direction))))));
+        })));
+    }
+    function DeliveryDetail(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        const [rawOpen, setRawOpen] = React.useState(false);
+        const rawId = React.useId();
+        const group = props.view.group;
+        const dropped = droppedEventCount(group);
+        const frames = group.events.filter((event) => event.safeErrorCode !== undefined);
+        const earliest = group.events[0]?.timestamp;
+        return (React.createElement("div", { className: "detail-pane" },
+            React.createElement("div", { className: "detail-pane__head" },
+                React.createElement("span", { className: "detail-pane__id" },
+                    group.messageIdSuffix ?? "—",
+                    group.conversationIdSuffix === undefined
+                        ? ""
+                        : ` · conv …${group.conversationIdSuffix}`,
+                    group.steer === true ? " · STEER" : ""),
+                React.createElement("div", { className: "detail-pane__sub" },
+                    props.view.routePair,
+                    " \u00B7 ",
+                    t(DIRECTION_COPY_KEYS[group.direction]))),
+            React.createElement("div", null,
+                React.createElement(Embassy.MonoLabel, { className: "section-label section-label--lifecycle" }, t("app.deliveries.lifecycle")),
+                React.createElement(DeliveryLifecycle, { group: group }),
+                props.view.eventsTruncated ? (React.createElement("p", { className: "truncation-note" }, t("app.deliveries.eventsTruncated", {
+                    count: fmtCount(locale, dropped),
+                }))) : null),
+            React.createElement("div", null,
+                React.createElement(Embassy.MonoLabel, { className: "section-label section-label--body" }, t("app.deliveries.bodyLabel")),
+                React.createElement("p", { className: "detail-pane__sub" }, t("app.deliveries.bodiesNote"))),
+            React.createElement("div", null,
+                React.createElement(Embassy.MonoLabel, { className: "section-label section-label--frames" }, t("app.deliveries.frames")),
+                frames.length === 0 ? (React.createElement("p", { className: "detail-pane__sub" }, t("app.deliveries.noFrames"))) : (React.createElement("div", { className: "frames-list" }, frames.map((event) => (React.createElement("div", { className: "frame-item", key: event.sequence },
+                    React.createElement("span", { className: "frame-code" }, event.safeErrorCode),
+                    event.timestamp === undefined ? (React.createElement("span", { className: "lifecycle-abs" }, t("time.unavailable"))) : (React.createElement(Embassy.TimeAgo, { iso: event.timestamp })))))))),
+            React.createElement("div", { className: "detail-list" },
+                group.latencyMs === undefined ? null : (React.createElement(DetailRow, { label: t("activity.column.elapsed"), mono: true }, `${fmtCount(locale, group.latencyMs)} ms`)),
+                React.createElement(DetailRow, { label: t("activity.column.size"), mono: true }, `${fmtCount(locale, group.bytes)} B`),
+                React.createElement(DetailRow, { label: t("app.deliveries.earliestRetained") }, earliest === undefined ? (t("time.unavailable")) : (React.createElement(React.Fragment, null,
+                    React.createElement(Embassy.TimeAgo, { iso: earliest }),
+                    " \u00B7 ",
+                    Embassy.fmtAbs(earliest, locale)))),
+                group.safeErrorCode === undefined ? null : (React.createElement(DetailRow, { label: t("column.issue"), mono: true }, group.safeErrorCode))),
+            React.createElement("div", null,
+                React.createElement("button", { type: "button", className: "toggle-link", "aria-expanded": rawOpen, "aria-controls": rawOpen ? rawId : undefined, onClick: () => {
+                        setRawOpen(!rawOpen);
+                    } }, rawOpen ? t("app.deliveries.hideRaw") : t("app.deliveries.raw")),
+                rawOpen ? (React.createElement("pre", { className: "raw-json", id: rawId, tabIndex: 0 }, JSON.stringify(group, null, 2))) : null)));
+    }
+    function DeliveriesEmpty(props) {
+        return (React.createElement("div", { className: "empty-state" },
+            React.createElement("p", { className: "empty-state__text" }, props.text),
+            React.createElement(Embassy.CopyCmd, { cmd: SEND_TO_CODEX_CMD })));
+    }
+    const WATCH_EVENT_COPY_KEYS = {
+        opened: "watches.event.opened",
+        nudge: "watches.event.nudge",
+        worker_reported_complete: "watches.event.workerReportedComplete",
+        capability_degraded: "watches.event.capabilityDegraded",
+        done: "watches.event.done",
+        unresponsive: "watches.event.unresponsive",
+        endpoint_retired: "watches.event.endpointRetired",
+        disabled: "watches.event.disabled",
+    };
+    function ProgressWatchRegister(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        return (React.createElement("section", { className: "watch-register", "aria-labelledby": "watch-register-title" },
+            React.createElement("div", { className: "row-baseline section-label" },
+                React.createElement("div", null,
+                    React.createElement(Embassy.MonoLabel, null, t("watches.eyebrow")),
+                    React.createElement("h2", { id: "watch-register-title" }, t("watches.title"))),
+                React.createElement("span", { className: "mono text-muted" }, fmtCount(locale, props.watches.length))),
+            React.createElement("p", { className: "footnote" }, t("watches.note")),
+            props.watches.length === 0 ? (React.createElement("p", { className: "watch-register__empty" }, t("watches.empty"))) : (React.createElement("div", { className: "watch-grid" }, props.watches.map((watch) => (React.createElement("article", { className: "watch-card", "data-phase": watch.phase, key: `${watch.ownerAlias}|${watch.workerAlias}|${watch.conversationIdSuffix}` },
+                React.createElement("div", { className: "watch-card__head" },
+                    React.createElement("code", null,
+                        "\u2026",
+                        watch.conversationIdSuffix),
+                    React.createElement(Embassy.StateChip, { domain: "severity", state: watch.phase === "episode" ? "warning" : "info", label: t(watch.phase === "episode"
+                            ? "watches.phase.episode"
+                            : "watches.phase.quiet"), note: t(watch.phase === "episode"
+                            ? "watches.phase.episode"
+                            : "watches.phase.quiet") })),
+                React.createElement("strong", null,
+                    watch.ownerAlias,
+                    " \u2192 ",
+                    watch.workerAlias),
+                React.createElement("dl", { className: "watch-card__facts" },
+                    React.createElement("div", null,
+                        React.createElement("dt", null, t("watches.column.quietFor")),
+                        React.createElement("dd", null,
+                            React.createElement(Embassy.TimeAgo, { iso: watch.lastActivityAt }))),
+                    React.createElement("div", null,
+                        React.createElement("dt", null, t("watches.column.nextAction")),
+                        React.createElement("dd", null,
+                            React.createElement(Embassy.TimeAgo, { iso: watch.nextActionAt }))),
+                    React.createElement("div", null,
+                        React.createElement("dt", null, t("watches.column.nudges")),
+                        React.createElement("dd", null, fmtCount(locale, watch.nudgeCount))),
+                    React.createElement("div", null,
+                        React.createElement("dt", null, t("watches.column.capability")),
+                        React.createElement("dd", null, t(watch.capability === "route" ? "watches.capability.route" : "watches.capability.conversation")))),
+                watch.workerReportedComplete ? (React.createElement("p", { className: "footnote" }, t("watches.workerComplete"))) : null))))),
+            props.events.length === 0 ? null : (React.createElement("details", { className: "watch-history" },
+                React.createElement("summary", null, t("watches.history.title")),
+                React.createElement("ol", null, props.events.map((event) => (React.createElement("li", { key: event.sequence },
+                    React.createElement(Embassy.TimeAgo, { iso: event.timestamp }),
+                    " \u00B7 ",
+                    React.createElement("code", null,
+                        "\u2026",
+                        event.conversationIdSuffix),
+                    " \u00B7 ",
+                    t(WATCH_EVENT_COPY_KEYS[event.kind]),
+                    event.nudgeNumber === undefined ? "" : ` #${event.nudgeNumber}`))))))));
+    }
+    function DeliveriesTab(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        const captionId = React.useId();
+        const searchId = React.useId();
+        const [directionFilter, setDirectionFilter] = React.useState("all");
+        const [stateFilter, setStateFilter] = React.useState("all");
+        const [viewMode, setViewMode] = React.useState("byRoute");
+        const [query, setQuery] = React.useState("");
+        const [selectedKey, setSelectedKey] = React.useState(undefined);
+        const rowRefs = React.useRef(new Map());
+        const groups = props.groups;
+        const preset = props.preset;
+        const clearPreset = props.clearPreset;
+        React.useEffect(() => {
+            if (preset === undefined)
+                return;
+            if (preset.state !== undefined)
+                setStateFilter(preset.state);
+            const token = preset.token === undefined ? "" : preset.token.trim();
+            if (token !== "") {
+                setQuery(token);
+                const target = findPresetTarget(groups, token);
+                if (target !== undefined)
+                    setSelectedKey(target.key);
+            }
+            clearPreset?.();
+        }, [preset]);
+        const needle = query.trim().toLowerCase();
+        const filtered = React.useMemo(() => groups.filter((view) => (directionFilter === "all" ||
+            view.group.direction === directionFilter) &&
+            (stateFilter === "all" || view.group.state === stateFilter) &&
+            matchesQuery(view, needle)), [groups, directionFilter, stateFilter, needle]);
+        const pairs = React.useMemo(() => groupByRoutePair(filtered), [filtered]);
+        const ordered = React.useMemo(() => (viewMode === "flat" ? filtered : pairs.flatMap((pair) => pair.rows)), [viewMode, filtered, pairs]);
+        const selectedView = ordered.find((view) => view.key === selectedKey);
+        const activeKey = selectedView?.key ?? ordered[0]?.key;
+        const moveFocus = (event) => {
+            const keys = ordered.map((view) => view.key);
+            if (keys.length === 0)
+                return;
+            const currentIndex = Math.max(0, activeKey === undefined ? 0 : keys.indexOf(activeKey));
+            let nextIndex;
+            switch (event.key) {
+                case "ArrowDown":
+                    nextIndex = Math.min(keys.length - 1, currentIndex + 1);
+                    break;
+                case "ArrowUp":
+                    nextIndex = Math.max(0, currentIndex - 1);
+                    break;
+                case "Home":
+                    nextIndex = 0;
+                    break;
+                case "End":
+                    nextIndex = keys.length - 1;
+                    break;
+                default:
+                    return;
+            }
+            const nextKey = keys[nextIndex];
+            if (nextKey === undefined)
+                return;
+            event.preventDefault();
+            setSelectedKey(nextKey);
+            rowRefs.current.get(nextKey)?.focus();
+        };
+        const renderRow = (view) => {
+            const group = view.group;
+            const isSelected = view.key === selectedView?.key;
+            return (React.createElement("button", { type: "button", key: view.key, className: "delivery-row", role: "option", "aria-selected": isSelected, tabIndex: view.key === activeKey ? 0 : -1, ref: (element) => {
+                    if (element === null)
+                        rowRefs.current.delete(view.key);
+                    else
+                        rowRefs.current.set(view.key, element);
+                }, onClick: () => {
+                    setSelectedKey(view.key);
+                } },
+                React.createElement("span", { className: "delivery-row__id" }, group.messageIdSuffix ?? "—"),
+                React.createElement("span", { className: "delivery-row__route", title: view.routePair }, view.routePair),
+                React.createElement(Embassy.StateChip, { small: true, state: group.state, direction: group.direction, safeErrorCode: group.safeErrorCode }),
+                group.steer === true ? (React.createElement("span", { className: "mono text-muted" }, "STEER")) : null,
+                React.createElement("span", { className: "delivery-row__time" }, group.timestamp === undefined ? (t("time.unavailable")) : (React.createElement(Embassy.TimeAgo, { iso: group.timestamp })))));
+        };
+        const list = ordered.length === 0 ? null : (React.createElement("div", { className: "delivery-list", role: "listbox", "aria-labelledby": captionId, onKeyDown: moveFocus }, viewMode === "flat"
+            ? filtered.map(renderRow)
+            : pairs.map((pair) => (React.createElement("div", { className: "delivery-group", role: "group", "aria-label": pair.pair, key: pair.pair },
+                React.createElement("div", { className: "delivery-group__head", "aria-hidden": true },
+                    React.createElement(Embassy.MonoLabel, null, t("activity.column.route")),
+                    React.createElement("span", { className: "delivery-group__key" }, pair.pair)),
+                pair.rows.map(renderRow),
+                React.createElement(Embassy.Rule, null))))));
+        return (React.createElement("div", { className: "deliveries-layout" },
+            React.createElement("div", { className: "deliveries-main" },
+                React.createElement("div", { className: "row-baseline section-label" },
+                    React.createElement("h2", { className: "text-xs text-muted", id: captionId }, t("app.deliveries.caption")),
+                    React.createElement("span", { className: "mono text-muted" }, t("attention.countVisible", {
+                        count: fmtCount(locale, ordered.length),
+                    })),
+                    props.omissions.messageGroups > 0 ? (React.createElement("span", { className: "lower-bound" }, t("app.lowerBound", {
+                        count: fmtCount(locale, groups.length),
+                    }))) : null),
+                React.createElement("div", { className: "filters" },
+                    React.createElement("div", { className: "filter-group" },
+                        React.createElement(Embassy.MonoLabel, null, t("app.deliveries.dir.label")),
+                        React.createElement("div", { className: "pill-row", role: "group", "aria-label": t("app.deliveries.dir.label") },
+                            React.createElement(Embassy.FilterPill, { active: directionFilter === "all", onClick: () => {
+                                    setDirectionFilter("all");
+                                } }, t("app.deliveries.dir.all")),
+                            DIRECTION_FILTERS.map((direction) => (React.createElement(Embassy.FilterPill, { key: direction, active: directionFilter === direction, onClick: () => {
+                                    setDirectionFilter(direction);
+                                } }, t(DIRECTION_PILL_COPY_KEYS[direction])))))),
+                    React.createElement("div", { className: "filter-group" },
+                        React.createElement(Embassy.MonoLabel, null, t("app.deliveries.view.label")),
+                        React.createElement("div", { className: "pill-row", role: "group", "aria-label": t("app.deliveries.view.label") },
+                            React.createElement(Embassy.FilterPill, { active: viewMode === "byRoute", onClick: () => {
+                                    setViewMode("byRoute");
+                                } }, t("app.deliveries.view.byRoute")),
+                            React.createElement(Embassy.FilterPill, { active: viewMode === "flat", onClick: () => {
+                                    setViewMode("flat");
+                                } }, t("app.deliveries.view.flat"))))),
+                React.createElement("p", { className: "footnote section-label" }, t("app.deliveries.noConv")),
+                React.createElement(ProgressWatchRegister, { watches: props.watches, events: props.watchEvents }),
+                React.createElement("div", { className: "filter-group filters-block" },
+                    React.createElement(Embassy.MonoLabel, null, t("column.state")),
+                    React.createElement("div", { className: "pill-row", role: "group", "aria-label": t("column.state") },
+                        React.createElement(Embassy.FilterPill, { active: stateFilter === "all", onClick: () => {
+                                setStateFilter("all");
+                            } }, t("app.deliveries.state.all")),
+                        DELIVERY_STATE_FILTERS.map((state) => (React.createElement(Embassy.FilterPill, { key: state, active: stateFilter === state, onClick: () => {
+                                setStateFilter(stateFilter === state ? "all" : state);
+                            } }, state))))),
+                React.createElement("div", { className: "filter-group filters-search" },
+                    React.createElement("label", { className: "sr-only", htmlFor: searchId }, t("app.deliveries.search")),
+                    React.createElement("input", { id: searchId, className: "text-input filter-input", type: "text", value: query, placeholder: t("app.deliveries.search"), onChange: (event) => {
+                            setQuery(event.target.value);
+                        } })),
+                props.omissions.messageEvents > 0 ? (React.createElement("p", { className: "footnote section-label" }, t("app.deliveries.eventsTruncated", {
+                    count: fmtCount(locale, props.omissions.messageEvents),
+                }))) : null,
+                groups.length === 0 ? (React.createElement(DeliveriesEmpty, { text: t("activity.empty") })) : ordered.length === 0 ? (React.createElement(DeliveriesEmpty, { text: t("app.deliveries.noMatch") })) : (React.createElement(React.Fragment, null,
+                    list,
+                    viewMode === "flat" ? React.createElement(Embassy.Rule, null) : null))),
+            React.createElement("div", { className: "deliveries-rail" }, selectedView === undefined ? (React.createElement("p", { className: "detail-pane__empty" }, t("app.deliveries.pickRow"))) : (React.createElement(DeliveryDetail, { key: selectedView.key, view: selectedView })))));
+    }
+    Embassy.DeliveriesTab = DeliveriesTab;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const TOPOLOGY_ROW_HEIGHT_PX = 64;
+    const TOPOLOGY_PADDING_PX = 18;
+    const TOPOLOGY_EDGE_WIDTH_PX = 220;
+    const SELECT_CLAUDE_COMMAND = "embassy select-claude --alias <alias>";
+    const REGISTER_CODEX_COMMAND = "embassy register-codex --alias codex-<name>@<host>";
+    const SUCCEEDS_COMMAND = "embassy register-codex --alias <new> --succeeds <old>";
+    const ROUTE_COUNTER_ROWS = [
+        ["accepted", "diagnostics.accepted"],
+        ["delivered", "diagnostics.delivered"],
+        ["unconfirmed", "diagnostics.unconfirmed"],
+        ["failed", "diagnostics.failed"],
+        ["ambiguous", "diagnostics.ambiguous"],
+        ["expired", "diagnostics.expired"],
+        ["cancelled", "diagnostics.cancelled"],
+        ["abandoned", "diagnostics.abandoned"],
+        ["rejected", "diagnostics.rejected"],
+        ["bytesAccepted", "diagnostics.bytesAccepted"],
+    ];
+    const countFormatters = new Map();
+    function formatCount(value, locale) {
+        const existing = countFormatters.get(locale);
+        if (existing !== undefined)
+            return existing.format(value);
+        const formatter = new Intl.NumberFormat(locale);
+        countFormatters.set(locale, formatter);
+        return formatter.format(value);
+    }
+    function isReadyCodexRoute(route) {
+        return (route.enabled &&
+            route.compatibility === "compatible" &&
+            (route.state === "idle" || route.state === "busy"));
+    }
+    function rowIdentity(alias, host) {
+        return `${alias}\u0000${host}`;
+    }
+    function topologyRowCenterY(index) {
+        return (TOPOLOGY_PADDING_PX +
+            index * TOPOLOGY_ROW_HEIGHT_PX +
+            TOPOLOGY_ROW_HEIGHT_PX / 2);
+    }
+    function topologyEdges(data) {
+        const claudeIndices = new Map(data.peers.map((peer, index) => [peer.alias, index]));
+        const codexIndices = new Map(data.codexRoutes.map((view, index) => [view.route.alias, index]));
+        const edges = [];
+        for (const pair of data.pairs) {
+            const claudeIndex = claudeIndices.get(pair.claudeAlias);
+            const codexIndex = codexIndices.get(pair.codexAlias);
+            if (claudeIndex === undefined || codexIndex === undefined)
+                continue;
+            edges.push({
+                claudeIndex,
+                codexIndex,
+                claudeAlias: pair.claudeAlias,
+                codexAlias: pair.codexAlias,
+                state: pair.state,
+            });
+        }
+        return edges;
+    }
+    function isEdgeEndpoint(edge, side, index) {
+        return side === "claude"
+            ? index === edge.claudeIndex
+            : index === edge.codexIndex;
+    }
+    function chipHighlight(focus, edges, side, index) {
+        if (focus === undefined)
+            return undefined;
+        if (focus.side === side && focus.index === index)
+            return "on";
+        if (focus.side !== side &&
+            edges.some((edge) => isEdgeEndpoint(edge, focus.side, focus.index) &&
+                isEdgeEndpoint(edge, side, index))) {
+            return "on";
+        }
+        return "off";
+    }
+    function edgeHighlight(focus, edge) {
+        if (focus === undefined)
+            return undefined;
+        return isEdgeEndpoint(edge, focus.side, focus.index) ? "on" : "off";
+    }
+    function TopologyColumn(props) {
+        const { side, highlightAt, onFocusChange } = props;
+        if (props.items.length === 0) {
+            return (React.createElement("div", { className: "topology__col" },
+                React.createElement("p", { className: "topology__empty" }, props.emptyText)));
+        }
+        return (React.createElement("div", { className: "topology__col" },
+            React.createElement("div", { role: "list", "aria-label": props.listLabel }, props.items.map((item, index) => (React.createElement("div", { key: item.key, role: "listitem", className: side === "claude"
+                    ? "topo-row topo-row--left"
+                    : "topo-row topo-row--right", onMouseEnter: () => {
+                    onFocusChange({ side, index });
+                }, onMouseLeave: () => {
+                    onFocusChange(undefined);
+                } },
+                React.createElement("span", { className: "topo-chip", "data-side": side, "data-candidate": item.candidate ? "true" : undefined, "data-highlight": highlightAt(side, index), tabIndex: 0, onFocus: () => {
+                        onFocusChange({ side, index });
+                    }, onBlur: () => {
+                        onFocusChange(undefined);
+                    } }, item.alias),
+                React.createElement("span", { className: "sr-only" }, item.srLabel)))))));
+    }
+    function TopologyEdgeSvg(props) {
+        const height = TOPOLOGY_PADDING_PX * 2 + props.rows * TOPOLOGY_ROW_HEIGHT_PX;
+        return (React.createElement("svg", { className: "topology__svg", width: TOPOLOGY_EDGE_WIDTH_PX, height: height, viewBox: `0 0 ${TOPOLOGY_EDGE_WIDTH_PX} ${height}`, "aria-hidden": "true", focusable: "false" }, props.edges.map((edge) => {
+            const highlight = edgeHighlight(props.focus, edge);
+            const stroke = highlight === "on"
+                ? props.focusSide === "codex"
+                    ? "var(--action-blue)"
+                    : "var(--coral-accent, var(--coral))"
+                : edge.state === "ready"
+                    ? "var(--hairline)"
+                    : "var(--warning)";
+            return (React.createElement("path", { key: `${edge.claudeAlias}\0${edge.codexAlias}`, fill: "none", d: `M 0 ${topologyRowCenterY(edge.claudeIndex)} C 80 ${topologyRowCenterY(edge.claudeIndex)} 140 ${topologyRowCenterY(edge.codexIndex)} ${TOPOLOGY_EDGE_WIDTH_PX} ${topologyRowCenterY(edge.codexIndex)}`, style: {
+                    stroke,
+                    strokeDasharray: edge.state === "ready" ? undefined : "5 4",
+                    strokeWidth: highlight === "on" ? 2 : 1.25,
+                    opacity: highlight === "off" ? 0.2 : 1,
+                } }));
+        })));
+    }
+    function DetailRow(props) {
+        return (React.createElement("p", { className: "detail-row" },
+            React.createElement("span", { className: "detail-label" },
+                props.label,
+                ": "),
+            props.children));
+    }
+    function AbsentDetail(props) {
+        const t = Embassy.useT();
+        return (React.createElement("p", { className: "detail-row" },
+            React.createElement("span", { className: "detail-value detail-value--mono" }, props.fields.join(" · ")),
+            React.createElement("span", { className: "detail-label" },
+                " \u2014 ",
+                t("app.routes.detail.absent"))));
+    }
+    function LowerBoundBadge(props) {
+        const t = Embassy.useT();
+        return (React.createElement("span", { className: "lower-bound" }, t("app.lowerBound", { count: props.count })));
+    }
+    function AccordionRow(props) {
+        const t = Embassy.useT();
+        const baseId = React.useId();
+        const buttonId = `${baseId}-summary`;
+        const panelId = `${baseId}-panel`;
+        return (React.createElement("div", { className: "accordion" },
+            React.createElement("button", { type: "button", id: buttonId, className: "accordion__row", "aria-label": t(props.open
+                    ? "app.routes.collapseDetails"
+                    : "app.routes.expandDetails", { alias: props.alias }), "aria-expanded": props.open, "aria-controls": props.open ? panelId : undefined, onClick: props.onToggle },
+                React.createElement("span", { className: "accordion__alias" }, props.alias),
+                props.head,
+                React.createElement("span", { className: "accordion__marker", "aria-hidden": "true" }, props.open ? "−" : "+")),
+            props.open ? (React.createElement("div", { className: "accordion__panel", id: panelId, role: "region", "aria-labelledby": buttonId },
+                React.createElement("div", { className: "detail-list" }, props.children))) : null));
+    }
+    function PeerAccordionRow(props) {
+        const t = Embassy.useT();
+        const peer = props.peer;
+        const selectionLabel = peer.selected
+            ? t("status.selected")
+            : peer.selectable
+                ? t("status.available")
+                : t("status.notSelectable");
+        return (React.createElement(AccordionRow, { alias: peer.alias, open: props.open, onToggle: props.onToggle, head: React.createElement(React.Fragment, null,
+                peer.selected ? (React.createElement("span", { className: "status-dot", title: t("status.selected"), "aria-hidden": "true" })) : null,
+                React.createElement(Embassy.StateChip, { domain: "peer", state: peer.state, small: true }),
+                peer.selected ? (React.createElement("span", { className: "chip chip--small", "data-kind": "positive" }, selectionLabel)) : null) },
+            React.createElement(DetailRow, { label: t("column.state") },
+                React.createElement(Embassy.StateChip, { domain: "peer", state: peer.state, small: true })),
+            React.createElement(DetailRow, { label: t("column.compatibility") },
+                React.createElement(Embassy.StateChip, { domain: "compatibility", state: peer.compatibility, small: true })),
+            React.createElement(DetailRow, { label: t("column.validation") },
+                React.createElement("span", { className: "chip chip--small", "data-kind": peer.validated ? "positive" : "warning" }, t(peer.validated
+                    ? "status.validated"
+                    : "status.validationRejected"))),
+            React.createElement(DetailRow, { label: t("column.selection") },
+                React.createElement("span", { className: "chip chip--small", "data-kind": peer.selected ? "positive" : "inert" }, selectionLabel)),
+            peer.selectionGuidance === undefined ? null : (React.createElement("p", { className: "detail-row" }, t(`peer.reason.${Embassy.camelCaseToken(peer.selectionGuidance)}`))),
+            React.createElement(DetailRow, { label: t("column.host") },
+                React.createElement("span", { className: "detail-value detail-value--mono" }, peer.host)),
+            React.createElement(DetailRow, { label: t("column.observed") }, peer.lastSeenAt === undefined ? (t("time.unavailable")) : (React.createElement(Embassy.TimeAgo, { iso: peer.lastSeenAt }))),
+            peer.safeErrorCode === undefined ? null : (React.createElement(DetailRow, { label: t("column.issue") },
+                React.createElement("span", { className: "detail-value detail-value--mono" }, peer.safeErrorCode))),
+            React.createElement(AbsentDetail, { fields: ["binding", "renames", "discovery"] }),
+            peer.selected || peer.selectable
+                ? props.codexRoutes.map((view) => {
+                    const codexAlias = view.route.alias;
+                    const paired = props.pairs.some((pair) => pair.claudeAlias === peer.alias &&
+                        pair.codexAlias === codexAlias);
+                    return (React.createElement(ActionControl, { key: codexAlias, action: {
+                            action: paired ? "unpair" : "pair",
+                            claudeAlias: peer.alias,
+                            codexAlias,
+                        }, consequence: t(paired
+                            ? "app.routes.unpairCmd.consequence"
+                            : "app.routes.pairCmd.consequence", { claude: peer.alias, codex: codexAlias }), enabled: props.actionsEnabled, onAction: props.onAction }));
+                })
+                : null));
+    }
+    function RouteCountersTable(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        return (React.createElement("details", { className: "details-block" },
+            React.createElement("summary", null, t("app.routes.counters")),
+            React.createElement("div", { className: "details-block__content" },
+                React.createElement("div", { className: "table-wrap" },
+                    React.createElement("table", { className: "data-table" },
+                        React.createElement("caption", { className: "table-caption" }, `${t("app.routes.counters")} — ${props.alias}`),
+                        React.createElement("tbody", null, ROUTE_COUNTER_ROWS.map(([field, copyKey]) => (React.createElement("tr", { key: field },
+                            React.createElement("th", { scope: "row" }, t(copyKey)),
+                            React.createElement("td", { className: "cell-mono" }, formatCount(props.counters[field], locale)))))))))));
+    }
+    function CodexAccordionRow(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        const route = props.view.route;
+        return (React.createElement(AccordionRow, { alias: route.alias, open: props.open, onToggle: props.onToggle, head: React.createElement(React.Fragment, null,
+                React.createElement("span", { className: "status-dot", title: t("app.routes.registered"), "aria-hidden": "true" }),
+                React.createElement(Embassy.StateChip, { domain: "route", state: route.state, small: true }),
+                props.view.monitorOnly ? (React.createElement("span", { className: "chip chip--small", "data-kind": "warning" }, t("app.routes.monitorOnly"))) : null) },
+            React.createElement(DetailRow, { label: t("column.state") },
+                React.createElement(Embassy.StateChip, { domain: "route", state: route.state, small: true })),
+            React.createElement(DetailRow, { label: t("column.compatibility") },
+                React.createElement(Embassy.StateChip, { domain: "compatibility", state: route.compatibility, small: true })),
+            React.createElement(DetailRow, { label: t("column.selection") },
+                React.createElement("span", { className: "chip chip--small", "data-kind": route.enabled ? "positive" : "inert" }, route.enabled ? t("status.enabled") : t("status.disabled"))),
+            React.createElement(DetailRow, { label: t("app.routes.queueDepth") },
+                React.createElement("span", { className: "detail-value detail-value--mono" }, formatCount(route.queueDepth, locale))),
+            props.view.oldestAgeMs === undefined ? null : (React.createElement(DetailRow, { label: t("app.overview.oldest") },
+                React.createElement("span", { className: "detail-value detail-value--mono" }, Embassy.fmtAge(props.view.oldestAgeMs)))),
+            props.view.monitorOnly ? (React.createElement("p", { className: "detail-row" }, t("app.routes.monitorOnlyReason"))) : null,
+            React.createElement(DetailRow, { label: t("column.host") },
+                React.createElement("span", { className: "detail-value detail-value--mono" }, route.host)),
+            React.createElement(DetailRow, { label: t("column.observed") }, route.lastSeenAt === undefined ? (t("time.unavailable")) : (React.createElement(Embassy.TimeAgo, { iso: route.lastSeenAt }))),
+            route.safeErrorCode === undefined ? null : (React.createElement(DetailRow, { label: t("column.issue") },
+                React.createElement("span", { className: "detail-value detail-value--mono" }, route.safeErrorCode))),
+            React.createElement(AbsentDetail, { fields: ["policy", "identity lock", "registered"] }),
+            React.createElement(RouteCountersTable, { alias: route.alias, counters: route.counters })));
+    }
+    function successionScope(item, t) {
+        const parts = [];
+        if (item.provider !== undefined)
+            parts.push(t(`provider.${item.provider}`));
+        if (item.alias !== undefined)
+            parts.push(item.alias);
+        if (item.host !== undefined)
+            parts.push(item.host);
+        if (item.code !== undefined)
+            parts.push(item.code);
+        return parts.join(" · ");
+    }
+    function SuccessionCard(props) {
+        const t = Embassy.useT();
+        const item = props.view.item;
+        const scope = successionScope(item, t);
+        return (React.createElement("article", { className: "succession-card" },
+            React.createElement("div", { className: "succession-card__head" },
+                React.createElement("div", { className: "chip-row" },
+                    React.createElement(Embassy.MonoLabel, null, "succession"),
+                    React.createElement(Embassy.StateChip, { domain: "severity", state: item.severity, small: true })),
+                item.timestamp === undefined ? null : (React.createElement(Embassy.TimeAgo, { iso: item.timestamp }))),
+            React.createElement("h3", { className: "card__title succession-card__title" }, t(`guidance.${props.view.guidanceKey}.title`)),
+            React.createElement("p", { className: "card__body" }, t(`guidance.${props.view.guidanceKey}.body`)),
+            scope === "" ? null : (React.createElement("p", { className: "attention-item__scope" },
+                t("attention.scope"),
+                ": ",
+                scope)),
+            React.createElement("p", { className: "card__body" }, t(`guidance.${props.view.guidanceKey}.action`)),
+            React.createElement(AbsentDetail, { fields: ["predecessor", "successor", "drain outcome"] }),
+            React.createElement("p", { className: "succession-note" }, t("app.routes.successions.note")),
+            React.createElement(Embassy.CopyCmd, { cmd: props.view.command })));
+    }
+    function actionLabelKey(action) {
+        switch (action.action) {
+            case "pair":
+                return "live.action.pair";
+            case "unpair":
+                return "live.action.unpair";
+            case "refresh_dashboard":
+                return "live.action.refresh";
+        }
+    }
+    function ActionControl(props) {
+        const t = Embassy.useT();
+        const [confirming, setConfirming] = React.useState(false);
+        const [pending, setPending] = React.useState(false);
+        const [result, setResult] = React.useState(undefined);
+        const actionIdentity = props.action.action === "refresh_dashboard"
+            ? props.action.action
+            : `${props.action.action}:${props.action.claudeAlias}:${props.action.codexAlias}`;
+        React.useEffect(() => {
+            setConfirming(false);
+            setPending(false);
+            setResult(undefined);
+        }, [actionIdentity]);
+        const baseLabel = t(actionLabelKey(props.action));
+        const label = props.action.action === "refresh_dashboard"
+            ? baseLabel
+            : `${baseLabel}: ${props.action.claudeAlias} ↔ ${props.action.codexAlias}`;
+        const confirm = async () => {
+            if (!props.enabled || pending)
+                return;
+            setPending(true);
+            setResult(undefined);
+            const next = await props.onAction(props.action);
+            setPending(false);
+            setConfirming(false);
+            setResult(next);
+        };
+        return (React.createElement("section", { className: "action-card", "aria-label": label },
+            React.createElement("h3", { className: "action-card__title" }, label),
+            React.createElement("p", { className: "action-card__consequence" }, props.consequence),
+            !props.enabled ? (React.createElement("p", { className: "action-card__status", role: "status" }, t("live.action.requiresConnected"))) : null,
+            result === undefined ? null : (React.createElement("p", { className: "action-card__status", "data-action-result": result.ok ? "success" : "failure", role: "status" }, t(result.ok ? "live.action.succeeded" : "live.action.failed", {
+                code: result.code,
+            }))),
+            confirming ? (React.createElement("div", { className: "action-card__buttons", role: "group", "aria-label": label },
+                React.createElement("button", { type: "button", className: "btn btn--primary", disabled: !props.enabled || pending, onClick: () => {
+                        void confirm();
+                    } }, pending ? t("live.action.pending") : t("live.action.confirm")),
+                React.createElement("button", { type: "button", className: "btn btn--ghost", disabled: pending, onClick: () => {
+                        setConfirming(false);
+                    } }, t("live.action.cancel")))) : (React.createElement("button", { type: "button", className: "btn btn--ghost", disabled: !props.enabled, onClick: () => {
+                    setResult(undefined);
+                    setConfirming(true);
+                } }, label))));
+    }
+    function RoutesTab(props) {
+        const t = Embassy.useT();
+        const data = props.data;
+        const openInbound = data.inboundMode === "open";
+        const [focus, setFocus] = React.useState(undefined);
+        const [openPeer, setOpenPeer] = React.useState(undefined);
+        const [openRoute, setOpenRoute] = React.useState(undefined);
+        const edges = topologyEdges(data);
+        const highlightAt = (side, index) => chipHighlight(focus, edges, side, index);
+        const claudeItems = data.peers.map((peer, index) => ({
+            key: `${rowIdentity(peer.alias, peer.host)}|${index}`,
+            alias: peer.alias,
+            candidate: !edges.some((edge) => edge.claudeAlias === peer.alias),
+            srLabel: edges.some((edge) => edge.claudeAlias === peer.alias)
+                ? t("status.selected")
+                : peer.selectable
+                    ? t("status.available")
+                    : t("status.notSelectable"),
+        }));
+        const codexItems = data.codexRoutes.map((view, index) => ({
+            key: `${rowIdentity(view.route.alias, view.route.host)}|${index}`,
+            alias: view.route.alias,
+            candidate: !edges.some((edge) => edge.codexAlias === view.route.alias),
+            srLabel: t(`route.${Embassy.camelCaseToken(view.route.state)}`),
+        }));
+        return (React.createElement("div", { className: "tab-panel" },
+            React.createElement("section", { className: "section", "aria-label": t("app.routes.topology") },
+                React.createElement(Embassy.MonoLabel, { className: "section-label" }, t("app.routes.topology")),
+                React.createElement("div", { className: "inbound-policy", "data-inbound-mode": data.inboundMode },
+                    React.createElement("span", { className: "chip chip--small", "data-kind": openInbound ? "warning" : "inert" }, t(openInbound
+                        ? "inbound.open.badge"
+                        : "inbound.paired.badge")),
+                    React.createElement("p", null, t(openInbound
+                        ? "inbound.open.body"
+                        : edges.length === 0
+                            ? "inbound.noPair.body"
+                            : "inbound.paired.body"))),
+                React.createElement("div", { className: "topology" },
+                    React.createElement("div", { className: "topology__heads" },
+                        React.createElement(Embassy.MonoLabel, { className: "topology__head--claude" }, t("provider.claude")),
+                        React.createElement(Embassy.MonoLabel, { className: "topology__head--codex" }, t("provider.codex"))),
+                    React.createElement("div", { className: "topology__cols" },
+                        React.createElement(TopologyColumn, { side: "claude", items: claudeItems, listLabel: t("app.routes.candidates"), emptyText: t("app.routes.noPeers"), highlightAt: highlightAt, onFocusChange: setFocus }),
+                        React.createElement(TopologyEdgeSvg, { rows: Math.max(claudeItems.length, codexItems.length), edges: edges, focus: focus, focusSide: focus === undefined ? undefined : focus.side }),
+                        React.createElement(TopologyColumn, { side: "codex", items: codexItems, listLabel: t("app.routes.codexRoutes"), emptyText: t("app.routes.noCodex"), highlightAt: highlightAt, onFocusChange: setFocus })),
+                    edges.length === 0 ? (React.createElement("p", { className: "topology__empty" }, t(openInbound
+                        ? "inbound.open.body"
+                        : "app.routes.noPairInline"))) : (React.createElement("ul", { className: "topology__edge-list", "aria-label": t("app.routes.pairs") }, edges.map((edge) => (React.createElement("li", { key: `${edge.claudeAlias}\0${edge.codexAlias}` },
+                        t("app.routes.pairDescription", {
+                            claude: edge.claudeAlias,
+                            codex: edge.codexAlias,
+                        }),
+                        " ",
+                        React.createElement(Embassy.StateChip, { domain: "route", state: edge.state === "ready" ? "idle" : "stale", small: true })))))),
+                    data.pairsOmitted > 0 ? (React.createElement("p", { className: "topology__empty" }, t("app.omitted.pairs", { count: data.pairsOmitted }))) : null),
+                React.createElement("section", { className: "section section__sub", "aria-label": t("live.action.sectionTitle") },
+                    React.createElement("div", { className: "row-baseline section-label" },
+                        React.createElement(Embassy.MonoLabel, null, t("live.action.sectionTitle"))),
+                    React.createElement("p", { className: "section-teaching" }, t("live.action.scope")),
+                    React.createElement("div", { className: "action-panel" },
+                        React.createElement(ActionControl, { action: { action: "refresh_dashboard" }, consequence: t("app.routes.refreshCmd"), enabled: props.actionsEnabled, onAction: props.onAction })))),
+            React.createElement("section", { className: "section", "aria-label": t("app.routes.claudeSessions") },
+                React.createElement("div", { className: "row-baseline row-baseline--split section-label" },
+                    React.createElement(Embassy.MonoLabel, null, t("app.routes.claudeSessions")),
+                    data.peersOmitted > 0 ? (React.createElement(LowerBoundBadge, { count: data.peers.length })) : null),
+                data.peers.length === 0 ? (React.createElement("div", { className: "empty-state" },
+                    React.createElement("p", { className: "empty-state__text" }, t("app.routes.noPeers")),
+                    React.createElement(Embassy.CopyCmd, { cmd: SELECT_CLAUDE_COMMAND }))) : (React.createElement("div", null, data.peers.map((peer, index) => {
+                    const identity = rowIdentity(peer.alias, peer.host);
+                    return (React.createElement(PeerAccordionRow, { key: `${identity}|${index}`, peer: peer, open: openPeer === identity, pairs: data.pairs, codexRoutes: data.codexRoutes, actionsEnabled: props.actionsEnabled, onAction: props.onAction, onToggle: () => {
+                            setOpenPeer(openPeer === identity ? undefined : identity);
+                        } }));
+                }))),
+                React.createElement(Embassy.Rule, null)),
+            React.createElement("section", { className: "section", "aria-label": t("app.routes.codexRoutes") },
+                React.createElement("div", { className: "row-baseline row-baseline--split section-label" },
+                    React.createElement(Embassy.MonoLabel, null, t("app.routes.codexRoutes")),
+                    data.routesOmitted > 0 ? (React.createElement(LowerBoundBadge, { count: data.codexRoutes.length })) : null),
+                data.codexRoutes.length === 0 ? (React.createElement("div", { className: "empty-state" },
+                    React.createElement("p", { className: "empty-state__text" }, t("app.routes.noCodex")))) : (React.createElement("div", null, data.codexRoutes.map((view, index) => {
+                    const identity = rowIdentity(view.route.alias, view.route.host);
+                    return (React.createElement(CodexAccordionRow, { key: `${identity}|${index}`, view: view, open: openRoute === identity, onToggle: () => {
+                            setOpenRoute(openRoute === identity ? undefined : identity);
+                        } }));
+                }))),
+                React.createElement(Embassy.Rule, null),
+                React.createElement("div", { className: "stack routes-register" },
+                    React.createElement("p", { className: "text-xs text-body-muted" }, t("app.routes.registerHint")),
+                    React.createElement(Embassy.CopyCmd, { cmd: REGISTER_CODEX_COMMAND }))),
+            React.createElement("section", { className: "section", "aria-label": t("app.routes.successions") },
+                React.createElement(Embassy.MonoLabel, { className: "section-label" }, t("app.routes.successions")),
+                data.successions.length === 0 ? (React.createElement("div", { className: "empty-state" },
+                    React.createElement("p", { className: "empty-state__text" }, t("app.routes.successions.empty")),
+                    React.createElement("p", { className: "succession-note" }, t("app.routes.successions.note")),
+                    React.createElement(Embassy.CopyCmd, { cmd: SUCCEEDS_COMMAND }))) : (React.createElement("div", { className: "stack-lg" }, data.successions.map((view, index) => (React.createElement(SuccessionCard, { key: `${view.guidanceKey}|${view.item.alias ?? ""}|${index}`, view: view }))))))));
+    }
+    Embassy.RoutesTab = RoutesTab;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const ACTIVITY_KINDS = [
+        "delivery",
+        "operation",
+        "alert",
+    ];
+    const ACTIVITY_KIND_LABEL_KEYS = {
+        delivery: "app.activity.kinds.delivery",
+        operation: "app.activity.kinds.operation",
+        alert: "app.activity.kinds.alert",
+    };
+    const OPERATION_COPY_KEYS = {
+        discovery_refreshed: "app.activity.operation.discoveryRefreshed",
+        claude_selected: "app.activity.operation.claudeSelected",
+        claude_unselected: "app.activity.operation.claudeUnselected",
+        codex_registered: "app.activity.operation.codexRegistered",
+        codex_succeeded: "app.activity.operation.codexSucceeded",
+        codex_unregistered: "app.activity.operation.codexUnregistered",
+        routes_paired: "app.activity.operation.routesPaired",
+        routes_unpaired: "app.activity.operation.routesUnpaired",
+        watch_ended: "app.activity.operation.watchEnded",
+    };
+    const ACTIVITY_EMPTY_COMMAND = "embassy send-to-codex --from <alias> --to <alias>";
+    const activityCountFormatters = new Map();
+    function formatCount(count, locale) {
+        const existing = activityCountFormatters.get(locale);
+        if (existing !== undefined)
+            return existing.format(count);
+        const formatter = new Intl.NumberFormat(locale);
+        activityCountFormatters.set(locale, formatter);
+        return formatter.format(count);
+    }
+    function countByKind(rows) {
+        let delivery = 0;
+        let operation = 0;
+        let alert = 0;
+        for (const row of rows) {
+            if (row.kind === "delivery")
+                delivery += 1;
+            else if (row.kind === "operation")
+                operation += 1;
+            else
+                alert += 1;
+        }
+        return { all: rows.length, delivery, operation, alert };
+    }
+    function kindIsLowerBound(kind, omissions) {
+        if (kind === "delivery") {
+            return omissions.messageGroups > 0 || omissions.upstreamMessageEvents > 0;
+        }
+        if (kind === "operation") {
+            return omissions.activityEvents > 0 || omissions.upstreamActivityEvents > 0;
+        }
+        return omissions.attentionItems > 0 || omissions.upstreamAlerts > 0;
+    }
+    function filterIsLowerBound(filter, omissions) {
+        return filter === "all"
+            ? ACTIVITY_KINDS.some((kind) => kindIsLowerBound(kind, omissions))
+            : kindIsLowerBound(filter, omissions);
+    }
+    function activityRowIdentity(row) {
+        if (row.kind === "delivery") {
+            return `delivery|${Embassy.deliveryGroupKey(row.group)}`;
+        }
+        if (row.kind === "operation") {
+            return `operation|${row.event.sequence}|${row.event.action}`;
+        }
+        const item = row.item;
+        return `alert|${row.timestamp}|${item.guidance}|${item.alias ?? ""}|${item.host ?? ""}|${item.code ?? ""}`;
+    }
+    function activityRowKeys(rows) {
+        const seen = new Map();
+        return rows.map((row) => {
+            const identity = activityRowIdentity(row);
+            const occurrence = seen.get(identity) ?? 0;
+            seen.set(identity, occurrence + 1);
+            return occurrence === 0 ? identity : `${identity}#${occurrence}`;
+        });
+    }
+    function alertScope(item, t) {
+        const parts = [];
+        if (item.provider !== undefined) {
+            parts.push(t(item.provider === "claude" ? "provider.claude" : "provider.codex"));
+        }
+        if (item.alias !== undefined)
+            parts.push(item.alias);
+        if (item.host !== undefined)
+            parts.push(item.host);
+        if (item.code !== undefined)
+            parts.push(item.code);
+        return parts.join(" · ");
+    }
+    function DeliveryEntryText(props) {
+        const group = props.group;
+        return (React.createElement("div", { className: "activity-text chip-row" },
+            React.createElement("span", { className: "mono" },
+                group.sourceAlias,
+                " \u2192 ",
+                group.targetAlias),
+            React.createElement(Embassy.StateChip, { small: true, state: group.state, direction: group.direction, safeErrorCode: group.safeErrorCode }),
+            group.steer === true ? (React.createElement("span", { className: "mono text-muted" }, "STEER")) : null,
+            group.messageIdSuffix === undefined ? null : (React.createElement("span", { className: "mono text-muted" }, group.messageIdSuffix))));
+    }
+    function AlertEntryText(props) {
+        const t = Embassy.useT();
+        const scope = alertScope(props.item, t);
+        return (React.createElement("div", { className: "activity-text stack-sm" },
+            React.createElement("div", { className: "chip-row" },
+                React.createElement(Embassy.StateChip, { small: true, domain: "severity", state: props.item.severity }),
+                React.createElement("span", null, t(`guidance.${props.guidanceKey}.title`))),
+            scope === "" ? null : (React.createElement("span", { className: "attention-item__scope" },
+                t("attention.scope"),
+                ": ",
+                scope))));
+    }
+    function OperationEntryText(props) {
+        const t = Embassy.useT();
+        const event = props.event;
+        return (React.createElement("div", { className: "activity-text stack-sm" },
+            React.createElement("div", { className: "chip-row" },
+                React.createElement("span", null, t(OPERATION_COPY_KEYS[event.action])),
+                React.createElement("span", { className: "mono text-muted" }, t(event.outcome === "accepted"
+                    ? "app.activity.operation.accepted"
+                    : "app.activity.operation.rejected"))),
+            event.aliases.length === 0 && event.safeErrorCode === undefined ? null : (React.createElement("span", { className: "attention-item__scope" }, [...event.aliases, event.safeErrorCode]
+                .filter((part) => part !== undefined)
+                .join(" · ")))));
+    }
+    function ActivityEntry(props) {
+        const t = Embassy.useT();
+        const row = props.row;
+        return (React.createElement("div", { className: "activity-row", role: "listitem" },
+            row.timestamp === undefined ? (React.createElement("span", { className: "time-ago text-muted", title: t("transit.unavailable") },
+                "\u2014",
+                React.createElement("span", { className: "sr-only" }, t("transit.unavailable")))) : (React.createElement(Embassy.TimeAgo, { iso: row.timestamp })),
+            React.createElement("span", { className: "activity-kind" }, t(ACTIVITY_KIND_LABEL_KEYS[row.kind])),
+            row.kind === "delivery" ? (React.createElement(DeliveryEntryText, { group: row.group })) : row.kind === "operation" ? (React.createElement(OperationEntryText, { event: row.event })) : (React.createElement(AlertEntryText, { item: row.item, guidanceKey: row.guidanceKey }))));
+    }
+    function ActivityTab(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        const headingId = React.useId();
+        const [kindFilter, setKindFilter] = React.useState("all");
+        const rows = props.rows;
+        const counts = React.useMemo(() => countByKind(rows), [rows]);
+        const shown = React.useMemo(() => kindFilter === "all"
+            ? rows
+            : rows.filter((row) => row.kind === kindFilter), [rows, kindFilter]);
+        const keys = React.useMemo(() => activityRowKeys(shown), [shown]);
+        const showAll = React.useCallback(() => {
+            setKindFilter("all");
+        }, []);
+        const toggleKind = React.useCallback((kind) => {
+            setKindFilter((current) => (current === kind ? "all" : kind));
+        }, []);
+        const isLowerBound = filterIsLowerBound(kindFilter, props.omissions);
+        return (React.createElement("section", { className: "section tab-panel--narrow", "aria-labelledby": headingId },
+            React.createElement("h2", { id: headingId, className: "mono-label section-label" }, t("app.activity.title")),
+            React.createElement("div", { className: "filters" },
+                React.createElement("div", { className: "filter-group" },
+                    React.createElement("div", { className: "pill-row" },
+                        React.createElement(Embassy.FilterPill, { active: kindFilter === "all", onClick: showAll },
+                            t("app.activity.kinds.all"),
+                            " ",
+                            React.createElement("span", { className: "pill__count" }, formatCount(counts.all, locale))),
+                        ACTIVITY_KINDS.map((kind) => (React.createElement(Embassy.FilterPill, { key: kind, active: kindFilter === kind, onClick: () => {
+                                toggleKind(kind);
+                            } },
+                            t(ACTIVITY_KIND_LABEL_KEYS[kind]),
+                            " ",
+                            React.createElement("span", { className: "pill__count" }, formatCount(counts[kind], locale)))))),
+                    isLowerBound ? (React.createElement("div", { className: "chip-row" },
+                        React.createElement("span", { className: "lower-bound" }, t("app.lowerBound", {
+                            count: formatCount(shown.length, locale),
+                        })))) : null)),
+            React.createElement("div", { className: "stack" },
+                shown.length === 0 ? (React.createElement("div", { className: "empty-state empty-state--activity" },
+                    React.createElement("p", { className: "empty-state__text" }, t("app.activity.empty")),
+                    React.createElement(Embassy.CopyCmd, { cmd: ACTIVITY_EMPTY_COMMAND }))) : (React.createElement("div", null,
+                    React.createElement("div", { className: "activity-list", role: "list" }, shown.map((row, index) => (React.createElement(ActivityEntry, { key: keys[index] ?? index, row: row })))),
+                    React.createElement(Embassy.Rule, null))),
+                React.createElement("p", { className: "footnote" }, t("app.activity.limited")))));
+    }
+    Embassy.ActivityTab = ActivityTab;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const DIAGNOSTICS_ABSENT_FIELD = "—";
+    const DIAGNOSTICS_CONNECTOR_COLUMNS = 7;
+    const diagnosticsNumberFormatters = new Map();
+    function diagnosticsNumberFormatter(locale) {
+        const existing = diagnosticsNumberFormatters.get(locale);
+        if (existing !== undefined)
+            return existing;
+        const formatter = new Intl.NumberFormat(locale);
+        diagnosticsNumberFormatters.set(locale, formatter);
+        return formatter;
+    }
+    function formatDiagnosticsCount(value, locale) {
+        return diagnosticsNumberFormatter(locale).format(value);
+    }
+    function formatDiagnosticsBytes(value, locale) {
+        if (value < 1_024) {
+            return `${formatDiagnosticsCount(value, locale)} B`;
+        }
+        if (value < 1_048_576) {
+            const kibibytes = value / 1_024;
+            const rounded = kibibytes < 10 ? Math.round(kibibytes * 10) / 10 : Math.round(kibibytes);
+            return `${formatDiagnosticsCount(rounded, locale)} KiB`;
+        }
+        const mebibytes = value / 1_048_576;
+        const rounded = mebibytes < 10 ? Math.round(mebibytes * 10) / 10 : Math.round(mebibytes);
+        return `${formatDiagnosticsCount(rounded, locale)} MiB`;
+    }
+    function DiagnosticsLowerBound(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        return (React.createElement("span", { className: "lower-bound" }, t("app.lowerBound", {
+            count: formatDiagnosticsCount(props.count, locale),
+        })));
+    }
+    function DiagnosticsConnectorTable(props) {
+        const t = Embassy.useT();
+        const { connectors } = props;
+        return (React.createElement("div", { className: "table-wrap" },
+            React.createElement("table", { className: "data-table" },
+                React.createElement("caption", { className: "sr-only" }, t("app.diag.versions.caption")),
+                React.createElement("thead", null,
+                    React.createElement("tr", null,
+                        React.createElement("th", { scope: "col" }, t("app.diag.col.provider")),
+                        React.createElement("th", { scope: "col" }, t("app.diag.col.host")),
+                        React.createElement("th", { scope: "col" }, t("app.diag.col.protocol")),
+                        React.createElement("th", { scope: "col" }, t("app.diag.col.version")),
+                        React.createElement("th", { scope: "col" }, t("diagnostics.health")),
+                        React.createElement("th", { scope: "col" }, t("app.diag.col.compat")),
+                        React.createElement("th", { scope: "col" }, t("column.issue")))),
+                React.createElement("tbody", null, connectors.length === 0 ? (React.createElement("tr", null,
+                    React.createElement("td", { colSpan: DIAGNOSTICS_CONNECTOR_COLUMNS }, t("diagnostics.connectors.empty")))) : (connectors.map((connector, index) => (React.createElement("tr", { key: `${connector.provider}|${connector.host}|${index}` },
+                    React.createElement("th", { scope: "row" }, connector.provider === "claude"
+                        ? t("provider.claude")
+                        : t("provider.codex")),
+                    React.createElement("td", { className: "cell-mono" }, connector.host),
+                    React.createElement("td", { className: "cell-mono" }, connector.protocol ?? DIAGNOSTICS_ABSENT_FIELD),
+                    React.createElement("td", { className: "cell-mono" }, connector.protocolVersion ?? DIAGNOSTICS_ABSENT_FIELD),
+                    React.createElement("td", null,
+                        React.createElement(Embassy.StateChip, { domain: "health", state: connector.health, small: true })),
+                    React.createElement("td", null,
+                        React.createElement(Embassy.StateChip, { domain: "compatibility", state: connector.compatibility, small: true })),
+                    React.createElement("td", { className: "cell-mono" }, connector.safeErrorCode ?? DIAGNOSTICS_ABSENT_FIELD)))))))));
+    }
+    function DiagnosticsCompatibilityTable(props) {
+        const t = Embassy.useT();
+        return (React.createElement("div", { className: "table-wrap" },
+            React.createElement("table", { className: "data-table" },
+                React.createElement("caption", { className: "sr-only" }, t("diagnostics.compatibilityChecks.caption")),
+                React.createElement("thead", null,
+                    React.createElement("tr", null,
+                        React.createElement("th", { scope: "col" }, t("app.diag.col.provider")),
+                        React.createElement("th", { scope: "col" }, t("diagnostics.version")),
+                        React.createElement("th", { scope: "col" }, t("diagnostics.tier")),
+                        React.createElement("th", { scope: "col" }, t("diagnostics.checkedAt")),
+                        React.createElement("th", { scope: "col" }, t("diagnostics.certification")),
+                        React.createElement("th", { scope: "col" }, t("diagnostics.certifiedAt")),
+                        React.createElement("th", { scope: "col" }, t("diagnostics.failedProbe")),
+                        React.createElement("th", { scope: "col" }, t("column.issue")))),
+                React.createElement("tbody", null, props.checks.length === 0 ? (React.createElement("tr", null,
+                    React.createElement("td", { colSpan: 8 }, t("diagnostics.compatibilityChecks.empty")))) : (props.checks.map((check) => (React.createElement("tr", { key: check.surface },
+                    React.createElement("th", { scope: "row" }, check.surface === "claude"
+                        ? t("provider.claude")
+                        : t("provider.codex")),
+                    React.createElement("td", { className: "cell-mono" }, check.version),
+                    React.createElement("td", null, t(`compatibilityTier.${check.tier}`)),
+                    React.createElement("td", null,
+                        React.createElement(Embassy.TimeAgo, { iso: check.checkedAt })),
+                    React.createElement("td", { className: "cell-mono" }, check.certificationOutcome === undefined
+                        ? DIAGNOSTICS_ABSENT_FIELD
+                        : `${check.certificationOutcome} / ${check.certificationDepth}`),
+                    React.createElement("td", null, check.certifiedAt === undefined
+                        ? DIAGNOSTICS_ABSENT_FIELD
+                        : React.createElement(Embassy.TimeAgo, { iso: check.certifiedAt })),
+                    React.createElement("td", { className: "cell-mono" }, check.failedProbe ?? DIAGNOSTICS_ABSENT_FIELD),
+                    React.createElement("td", { className: "cell-mono" }, check.certificationSafeErrorCode ??
+                        check.safeErrorCode ??
+                        DIAGNOSTICS_ABSENT_FIELD)))))))));
+    }
+    function DiagnosticsCounterTable(props) {
+        return (React.createElement("div", { className: "table-wrap counters-list" },
+            React.createElement("table", { className: "data-table data-table--counters" },
+                React.createElement("caption", { className: "table-caption" }, props.caption),
+                React.createElement("tbody", null, props.rows.map((row) => (React.createElement("tr", { key: row.id },
+                    React.createElement("th", { scope: "row" }, row.label),
+                    React.createElement("td", { className: "cell-mono" }, row.value)))))),
+            React.createElement(Embassy.Rule, null)));
+    }
+    function DiagnosticsOmissionTable(props) {
+        return (React.createElement("div", { className: "table-wrap" },
+            React.createElement("table", { className: "data-table" },
+                React.createElement("caption", { className: "table-caption" }, props.caption),
+                React.createElement("tbody", null, props.rows.map((row) => (React.createElement("tr", { key: row.field },
+                    React.createElement("th", { scope: "row", className: "cell-mono" }, row.field),
+                    React.createElement("td", null, row.text)))))),
+            React.createElement(Embassy.Rule, null)));
+    }
+    function DiagnosticsDisclosure(props) {
+        const t = Embassy.useT();
+        const [open, setOpen] = React.useState(false);
+        return (React.createElement("details", { className: "details-block", onToggle: (event) => {
+                setOpen(event.currentTarget.open);
+            } },
+            React.createElement("summary", null,
+                props.label,
+                " \u00B7 ",
+                open ? t("app.hide") : t("app.show")),
+            props.children));
+    }
+    function DiagnosticsSetting(props) {
+        const { setting } = props;
+        return (React.createElement("div", { className: "setting-row" },
+            React.createElement("div", { className: "row-baseline" },
+                React.createElement("span", { className: setting.nameIsToken
+                        ? "detail-value detail-value--mono"
+                        : "detail-value" }, setting.name),
+                React.createElement("span", { className: "mono-label" }, setting.where)),
+            React.createElement("div", { className: "env-name" }, setting.envName ?? DIAGNOSTICS_ABSENT_FIELD),
+            setting.note === undefined ? null : (React.createElement("p", { className: "footnote" }, setting.note))));
+    }
+    function DiagnosticsTab(props) {
+        const t = Embassy.useT();
+        const [locale] = Embassy.useLocale();
+        const { data } = props;
+        const versionsHeadingId = React.useId();
+        const limitsHeadingId = React.useId();
+        const deadlineHeadingId = React.useId();
+        const queueHeadingId = React.useId();
+        const bytesHeadingId = React.useId();
+        const settingsHeadingId = React.useId();
+        const deadlineIsWarn = data.expiredCount > 0;
+        const deadlineBucketKeys = {
+            under_1m: "app.diag.deadline.bucket.under1m",
+            "1m_to_5m": "app.diag.deadline.bucket.1to5m",
+            "5m_to_15m": "app.diag.deadline.bucket.5to15m",
+            "15m_to_60m": "app.diag.deadline.bucket.15to60m",
+            over_60m: "app.diag.deadline.bucket.over60m",
+        };
+        const accounting = data.accounting;
+        const accountingRows = [
+            {
+                id: "accepted",
+                label: t("diagnostics.accepted"),
+                value: formatDiagnosticsCount(accounting.accepted, locale),
+            },
+            {
+                id: "duplicates",
+                label: t("diagnostics.duplicates"),
+                value: formatDiagnosticsCount(accounting.duplicates, locale),
+            },
+            {
+                id: "delivered",
+                label: t("diagnostics.delivered"),
+                value: formatDiagnosticsCount(accounting.delivered, locale),
+            },
+            {
+                id: "unconfirmed",
+                label: t("diagnostics.unconfirmed"),
+                value: formatDiagnosticsCount(accounting.unconfirmed, locale),
+            },
+            {
+                id: "ambiguous",
+                label: t("diagnostics.ambiguous"),
+                value: formatDiagnosticsCount(accounting.ambiguous, locale),
+            },
+            {
+                id: "failed",
+                label: t("diagnostics.failed"),
+                value: formatDiagnosticsCount(accounting.failed, locale),
+            },
+            {
+                id: "expired",
+                label: t("diagnostics.expired"),
+                value: formatDiagnosticsCount(accounting.expired, locale),
+            },
+            {
+                id: "cancelled",
+                label: t("diagnostics.cancelled"),
+                value: formatDiagnosticsCount(accounting.cancelled, locale),
+            },
+            {
+                id: "abandoned",
+                label: t("diagnostics.abandoned"),
+                value: formatDiagnosticsCount(accounting.abandoned, locale),
+            },
+            {
+                id: "rejected",
+                label: t("diagnostics.rejected"),
+                value: formatDiagnosticsCount(accounting.rejected, locale),
+            },
+            {
+                id: "bytesAccepted",
+                label: t("diagnostics.bytesAccepted"),
+                value: formatDiagnosticsBytes(accounting.bytesAccepted, locale),
+            },
+            {
+                id: "queuedBytes",
+                label: t("diagnostics.queuedBytes"),
+                value: formatDiagnosticsBytes(accounting.queuedBytes, locale),
+            },
+        ];
+        const omissions = data.omissions;
+        const omissionRows = [
+            {
+                field: "connectors",
+                text: t("diagnostics.omissions.connectors", {
+                    count: formatDiagnosticsCount(omissions.connectors, locale),
+                }),
+            },
+            {
+                field: "availablePeers",
+                text: t("diagnostics.omissions.peers", {
+                    count: formatDiagnosticsCount(omissions.availablePeers, locale),
+                }),
+            },
+            {
+                field: "routes",
+                text: t("diagnostics.omissions.routes", {
+                    count: formatDiagnosticsCount(omissions.routes, locale),
+                }),
+            },
+            {
+                field: "upstreamMessageEvents",
+                text: t("diagnostics.omissions.upstreamMessageEvents", {
+                    count: formatDiagnosticsCount(omissions.upstreamMessageEvents, locale),
+                }),
+            },
+            {
+                field: "messageGroups",
+                text: t("diagnostics.omissions.messageGroups", {
+                    count: formatDiagnosticsCount(omissions.messageGroups, locale),
+                }),
+            },
+            {
+                field: "messageEvents",
+                text: t("diagnostics.omissions.messageEvents", {
+                    count: formatDiagnosticsCount(omissions.messageEvents, locale),
+                }),
+            },
+            {
+                field: "upstreamAlerts",
+                text: t("diagnostics.omissions.upstreamAlerts", {
+                    count: formatDiagnosticsCount(omissions.upstreamAlerts, locale),
+                }),
+            },
+            {
+                field: "attentionItems",
+                text: t("diagnostics.omissions.attentionItems", {
+                    count: formatDiagnosticsCount(omissions.attentionItems, locale),
+                }),
+            },
+        ];
+        const nothingOmitted = omissions.connectors === 0 &&
+            omissions.availablePeers === 0 &&
+            omissions.routes === 0 &&
+            omissions.upstreamMessageEvents === 0 &&
+            omissions.messageGroups === 0 &&
+            omissions.messageEvents === 0 &&
+            omissions.upstreamAlerts === 0 &&
+            omissions.attentionItems === 0;
+        const settings = [
+            {
+                id: "deadline",
+                name: t("app.diag.deadline.title"),
+                nameIsToken: false,
+                envName: "EMBASSY_MESSAGE_DEADLINE_MS",
+                where: t("app.tab.diagnostics"),
+                note: undefined,
+            },
+            {
+                id: "queueDepth",
+                name: t("app.diag.queue.title"),
+                nameIsToken: false,
+                envName: "EMBASSY_MAX_QUEUE_MESSAGES",
+                where: t("app.tab.overview"),
+                note: undefined,
+            },
+            {
+                id: "deliveryNotices",
+                name: t("app.diag.deliveryNotices.title"),
+                nameIsToken: false,
+                envName: "EMBASSY_DELIVERY_NOTICES",
+                where: t("app.tab.diagnostics"),
+                note: t("app.diag.deliveryNotices.note"),
+            },
+            {
+                id: "steering",
+                name: "steering",
+                nameIsToken: true,
+                envName: undefined,
+                where: t("app.tab.diagnostics"),
+                note: undefined,
+            },
+            {
+                id: "inboundMode",
+                name: "inbound mode",
+                nameIsToken: true,
+                envName: undefined,
+                where: t("app.tab.routes"),
+                note: t("app.routes.detail.absent"),
+            },
+        ];
+        return (React.createElement("div", { className: "tab-panel tab-panel--narrow" },
+            React.createElement("section", { className: "section", "aria-labelledby": settingsHeadingId },
+                React.createElement("h2", { className: "mono-label section-label", id: settingsHeadingId }, t("app.diag.editable.title")),
+                React.createElement("div", { className: "stack-lg" },
+                    React.createElement("div", { className: "grid-2" },
+                        React.createElement("section", { className: deadlineIsWarn ? "card card--warn" : "card", "aria-labelledby": deadlineHeadingId },
+                            React.createElement("div", { className: "card__head" },
+                                React.createElement("h3", { className: "card__title", id: deadlineHeadingId }, t("app.diag.deadline.title")),
+                                deadlineIsWarn ? (React.createElement(Embassy.StateChip, { domain: "severity", state: "warning", small: true })) : null),
+                            React.createElement("p", { className: "card__body" }, t("app.diag.deadline.body", {
+                                count: formatDiagnosticsCount(data.expiredCount, locale),
+                            })),
+                            data.deadlinePressure === undefined ? null : (React.createElement("div", { className: "stack-sm" },
+                                React.createElement("p", { className: "footnote" }, t("app.diag.deadline.retained", {
+                                    terminal: formatDiagnosticsCount(data.deadlinePressure.terminalEvents, locale),
+                                    expired: formatDiagnosticsCount(data.deadlinePressure.expiredEvents, locale),
+                                    deadline: Embassy.fmtAge(data.deadlinePressure.configuredDeadlineMs),
+                                })),
+                                React.createElement("dl", { className: "detail-list" }, data.deadlinePressure.buckets.map((bucket) => (React.createElement(React.Fragment, { key: bucket.bucket },
+                                    React.createElement("dt", null, t(deadlineBucketKeys[bucket.bucket])),
+                                    React.createElement("dd", null,
+                                        formatDiagnosticsCount(bucket.settled, locale),
+                                        " \u00B7 ",
+                                        formatDiagnosticsCount(bucket.expired, locale),
+                                        " ",
+                                        t("delivery.expired")))))))),
+                            React.createElement("p", { className: "env-name" }, "EMBASSY_MESSAGE_DEADLINE_MS"),
+                            React.createElement(Embassy.CopyCmd, { cmd: "EMBASSY_MESSAGE_DEADLINE_MS=<ms> embassy serve" })),
+                        React.createElement(Embassy.AbsentFeature, { title: t("app.diag.steering.title"), body: t("app.diag.steering.absent") })),
+                    React.createElement("div", { className: "setting-list" }, settings.map((setting) => (React.createElement(DiagnosticsSetting, { key: setting.id, setting: setting })))),
+                    React.createElement("p", { className: "footnote" }, t("app.diag.editable.note")))),
+            React.createElement("section", { className: "section", "aria-labelledby": versionsHeadingId },
+                React.createElement("div", { className: "row-baseline section-label" },
+                    React.createElement("h2", { className: "mono-label", id: versionsHeadingId }, t("app.diag.versions")),
+                    data.connectorsOmitted > 0 ? (React.createElement(DiagnosticsLowerBound, { count: data.connectors.length })) : null),
+                React.createElement("div", { className: "stack" },
+                    React.createElement(DiagnosticsConnectorTable, { connectors: data.connectors }),
+                    React.createElement("p", { className: "footnote" }, t("app.diag.versions.rangeAbsent")))),
+            React.createElement("div", { className: "grid-2" },
+                React.createElement("section", { className: "card", "aria-labelledby": "compatibility-attestation-title" },
+                    React.createElement("div", { className: "card__head" },
+                        React.createElement("h3", { className: "card__title", id: "compatibility-attestation-title" }, t("app.diag.attestation.title"))),
+                    React.createElement(DiagnosticsCompatibilityTable, { checks: data.compatibilityChecks }),
+                    React.createElement(Embassy.CopyCmd, { cmd: "embassy compat-check" })),
+                React.createElement(Embassy.AbsentFeature, { title: t("app.diag.lease.title"), body: t("app.diag.lease.absent"), cmd: "embassy status" })),
+            React.createElement("section", { className: "section", "aria-labelledby": limitsHeadingId },
+                React.createElement("h2", { className: "mono-label section-label", id: limitsHeadingId }, t("app.diag.limits")),
+                React.createElement("div", { className: "stack" },
+                    React.createElement("section", { className: "card", "aria-labelledby": queueHeadingId },
+                        React.createElement("div", { className: "card__head" },
+                            React.createElement("h3", { className: "card__title", id: queueHeadingId }, t("app.diag.queue.title")),
+                            data.queueCountIsLowerBound ? (React.createElement(DiagnosticsLowerBound, { count: data.queuedMessages })) : null),
+                        React.createElement("p", { className: "card__body" }, t("app.diag.queue.body", {
+                            count: formatDiagnosticsCount(data.queuedMessages, locale),
+                        })),
+                        React.createElement("p", { className: "env-name" }, "EMBASSY_MAX_QUEUE_MESSAGES"),
+                        React.createElement(Embassy.CopyCmd, { cmd: "EMBASSY_MAX_QUEUE_MESSAGES=<n> embassy serve" })),
+                    React.createElement("section", { className: "card", "aria-labelledby": bytesHeadingId },
+                        React.createElement("div", { className: "card__head" },
+                            React.createElement("h3", { className: "card__title", id: bytesHeadingId }, t("app.diag.bytes.title"))),
+                        React.createElement("p", { className: "card__body" }, t("app.diag.bytes.body", {
+                            queued: formatDiagnosticsBytes(accounting.queuedBytes, locale),
+                            accepted: formatDiagnosticsBytes(accounting.bytesAccepted, locale),
+                        })),
+                        React.createElement("p", { className: "env-name" }, "EMBASSY_MAX_MESSAGE_BYTES"),
+                        React.createElement(Embassy.CopyCmd, { cmd: "EMBASSY_MAX_MESSAGE_BYTES=<n> embassy serve" })),
+                    React.createElement("p", { className: "footnote" }, t("app.diag.limits.hint")))),
+            React.createElement("section", { className: "section" },
+                React.createElement(DiagnosticsDisclosure, { label: t("app.diag.counters") },
+                    React.createElement("div", { className: "details-block__content" },
+                        React.createElement(DiagnosticsCounterTable, { caption: t("app.diag.counters.caption"), rows: accountingRows }))),
+                React.createElement(DiagnosticsDisclosure, { label: t("app.diag.omissions") },
+                    React.createElement("div", { className: "details-block__content stack" },
+                        React.createElement(DiagnosticsOmissionTable, { caption: t("app.diag.omissions.caption"), rows: omissionRows }),
+                        nothingOmitted ? (React.createElement("p", { className: "footnote" }, t("diagnostics.omissions.none"))) : null)))));
+    }
+    Embassy.DiagnosticsTab = DiagnosticsTab;
+})(Embassy || (Embassy = {}));
+var Embassy;
+(function (Embassy) {
+    const PREFS_STORAGE_KEY = "embassy-live-prefs";
+    const STALE_NOTICE_MS = 35_000;
+    const TAB_KEYS = [
+        "overview",
+        "deliveries",
+        "routes",
+        "activity",
+        "diagnostics",
+    ];
+    function isTabKey(value) {
+        return (typeof value === "string" &&
+            TAB_KEYS.includes(value));
+    }
+    function loadPrefs(fallbackLocale) {
+        try {
+            const raw = window.localStorage.getItem(PREFS_STORAGE_KEY);
+            if (raw !== null) {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed === "object" && parsed !== null) {
+                    const record = parsed;
+                    const locale = record["locale"];
+                    const tab = record["tab"];
+                    return {
+                        locale: locale === "en" || locale === "zh-CN" ? locale : fallbackLocale,
+                        tab: isTabKey(tab) ? tab : "overview",
+                    };
+                }
+            }
+        }
+        catch {
+        }
+        return { locale: fallbackLocale, tab: "overview" };
+    }
+    function savePrefs(prefs) {
+        try {
+            window.localStorage.setItem(PREFS_STORAGE_KEY, JSON.stringify(prefs));
+        }
+        catch {
+        }
+    }
+    function Notice(props) {
+        const t = Embassy.useT();
+        return (React.createElement("div", { className: "notice", "data-tone": props.tone, role: "status" },
+            React.createElement("span", null, props.text),
+            React.createElement("button", { type: "button", className: "toggle-link", onClick: props.onDismiss }, t("app.hide"))));
+    }
+    function Shell(props) {
+        const t = Embassy.useT();
+        const [locale, setLocale] = Embassy.useLocale();
+        const [tab, setTab] = React.useState(props.initialTab);
+        const [latest, setLatest] = React.useState(undefined);
+        const [connectionState, setConnectionState] = React.useState("connecting");
+        const [lastFrameAtMs, setLastFrameAtMs] = React.useState(undefined);
+        const [notices, setNotices] = React.useState({
+            reset: false,
+            missedFrames: false,
+        });
+        const [preset, setPreset] = React.useState(undefined);
+        const [query, setQuery] = React.useState("");
+        const nowMs = Embassy.useNowMs();
+        const protocolRef = React.useRef(undefined);
+        const tabRefs = React.useRef([]);
+        React.useEffect(() => {
+            const protocol = Embassy.createProtocol({
+                onEvent: (event) => {
+                    setLatest(event);
+                    setLastFrameAtMs(Date.now());
+                },
+                onConnectionState: setConnectionState,
+                onNotice: (kind) => {
+                    setNotices((previous) => ({ ...previous, [kind]: true }));
+                },
+            });
+            protocolRef.current = protocol;
+            protocol.start();
+            return () => {
+                protocolRef.current = undefined;
+                protocol.pause();
+            };
+        }, []);
+        React.useEffect(() => {
+            document.documentElement.lang = locale;
+        }, [locale]);
+        React.useEffect(() => {
+            savePrefs({ locale, tab });
+        }, [locale, tab]);
+        const goDeliveries = React.useCallback((next) => {
+            setPreset(next);
+            setTab("deliveries");
+        }, []);
+        const clearPreset = React.useCallback(() => {
+            setPreset(undefined);
+        }, []);
+        const runAction = React.useCallback(async (action) => protocolRef.current?.executeAction(action) ?? {
+            ok: false,
+            code: "unavailable",
+        }, []);
+        const dismissNotice = (kind) => {
+            setNotices((previous) => ({ ...previous, [kind]: false }));
+        };
+        const onSearchKeyDown = (event) => {
+            if (event.key !== "Enter")
+                return;
+            const token = query.trim();
+            if (token === "")
+                return;
+            setPreset({ token });
+            setTab("deliveries");
+            setQuery("");
+        };
+        const onTabKeyDown = (event) => {
+            const currentIndex = TAB_KEYS.indexOf(tab);
+            let nextIndex;
+            if (event.key === "ArrowRight") {
+                nextIndex = (currentIndex + 1) % TAB_KEYS.length;
+            }
+            else if (event.key === "ArrowLeft") {
+                nextIndex = (currentIndex - 1 + TAB_KEYS.length) % TAB_KEYS.length;
+            }
+            else if (event.key === "Home") {
+                nextIndex = 0;
+            }
+            else if (event.key === "End") {
+                nextIndex = TAB_KEYS.length - 1;
+            }
+            if (nextIndex === undefined)
+                return;
+            event.preventDefault();
+            const nextTab = TAB_KEYS[nextIndex];
+            if (nextTab === undefined)
+                return;
+            setTab(nextTab);
+            tabRefs.current[nextIndex]?.focus();
+        };
+        const generatedAt = latest?.model.generatedAt;
+        const staleAgeMs = lastFrameAtMs === undefined ? undefined : nowMs - lastFrameAtMs;
+        const hasNotices = notices.reset || notices.missedFrames;
+        function renderActiveTab() {
+            if (latest === undefined) {
+                return (React.createElement("div", { className: "empty-state" },
+                    React.createElement("p", { className: "empty-state__text" }, t(`live.connection.${connectionState}`))));
+            }
+            const model = latest.model;
+            switch (tab) {
+                case "overview":
+                    return (React.createElement(Embassy.OverviewTab, { data: Embassy.adapter.overviewProps(model, nowMs), onViewDeliveries: goDeliveries }));
+                case "deliveries":
+                    return (React.createElement(Embassy.DeliveriesTab, { groups: Embassy.adapter.deliveriesGroups(model), watches: model.watches ?? [], watchEvents: model.watchEvents ?? [], omissions: model.omissions, preset: preset, clearPreset: clearPreset }));
+                case "routes":
+                    return (React.createElement(Embassy.RoutesTab, { data: Embassy.adapter.routesProps(model, nowMs), actionsEnabled: connectionState === "connected", onAction: runAction }));
+                case "activity":
+                    return (React.createElement(Embassy.ActivityTab, { rows: Embassy.adapter.activityRows(model), omissions: model.omissions }));
+                case "diagnostics":
+                    return React.createElement(Embassy.DiagnosticsTab, { data: Embassy.adapter.diagnosticsProps(model) });
+            }
+        }
+        return (React.createElement("div", { className: "app-shell" },
+            React.createElement("header", { className: "app-header" },
+                React.createElement("div", { className: "header-bar" },
+                    React.createElement("div", { className: "brand" },
+                        React.createElement("svg", { width: "26", height: "26", viewBox: "0 0 64 64", fill: "none", "aria-hidden": "true", className: "brand-mark" },
+                            React.createElement("path", { d: "M32 16 V5 L41 7.5 L32 10", fill: "#f4a259" }),
+                            React.createElement("path", { d: "M21.5 55 V32 C21.5 23 42.5 23 42.5 32 V55 Z", fill: "#f4a259" }),
+                            React.createElement("path", { d: "M14 55 V30.5 C14 17 50 17 50 30.5 V55", stroke: "#17171c", strokeWidth: "3.4", strokeLinecap: "round" }),
+                            React.createElement("path", { d: "M10 55.5 H54", stroke: "#17171c", strokeWidth: "3", strokeLinecap: "round" })),
+                        React.createElement("span", { className: "brand-wordmark" }, "Embassy"),
+                        React.createElement("span", { className: "mono-label" }, t("live.label")),
+                        latest === undefined ? null : (React.createElement("span", { className: "brand-posture" },
+                            React.createElement(Embassy.StateChip, { domain: "overall", state: latest.model.overall, small: true })))),
+                    React.createElement("div", { className: "header-spacer" }),
+                    React.createElement("input", { type: "search", className: "text-input header-search", value: query, onChange: (event) => {
+                            setQuery(event.target.value);
+                        }, onKeyDown: onSearchKeyDown, "aria-label": t("app.search.label"), placeholder: t("app.search.placeholder") }),
+                    React.createElement("div", { className: "header-meta" },
+                        React.createElement("span", { className: "as-of", title: generatedAt }, t("app.asOf", {
+                            time: generatedAt === undefined
+                                ? t("time.unavailable")
+                                : Embassy.fmtAbs(generatedAt, locale),
+                        })),
+                        React.createElement("span", { className: "conn-status", "aria-live": "polite" },
+                            React.createElement(Embassy.StateChip, { domain: "connection", state: connectionState, label: t(`live.connection.${connectionState}`), small: true })),
+                        React.createElement("div", { className: "lang-toggle" },
+                            React.createElement("button", { type: "button", className: "lang-toggle__btn", "aria-pressed": locale === "en", onClick: () => {
+                                    setLocale("en");
+                                } }, "EN"),
+                            React.createElement("button", { type: "button", className: "lang-toggle__btn", "aria-pressed": locale === "zh-CN", onClick: () => {
+                                    setLocale("zh-CN");
+                                } }, "\u4E2D\u6587"))),
+                    React.createElement("div", { className: "header-subrow" },
+                        staleAgeMs !== undefined && staleAgeMs >= STALE_NOTICE_MS ? (React.createElement("p", { className: connectionState === "connected"
+                                ? "staleness staleness--quiet"
+                                : "staleness", role: "status" }, connectionState === "connected"
+                            ? t("app.staleQuiet", { age: Embassy.fmtAge(staleAgeMs) })
+                            : t("app.stale", { age: Embassy.fmtAge(staleAgeMs) }))) : null,
+                        React.createElement("span", { className: "conn-controls" },
+                            React.createElement("button", { type: "button", className: "btn btn--ghost", onClick: () => protocolRef.current?.pause() }, t("live.control.pause")),
+                            React.createElement("button", { type: "button", className: "btn btn--ghost", onClick: () => protocolRef.current?.reconnect() }, t("live.control.reconnect")),
+                            React.createElement("button", { type: "button", className: "btn btn--ghost", onClick: () => protocolRef.current?.readNow() }, t("live.control.refresh"))))),
+                React.createElement("nav", { className: "app-nav", role: "tablist", "aria-label": t("live.label") }, TAB_KEYS.map((key, index) => (React.createElement("button", { key: key, type: "button", role: "tab", id: `tab-${key}`, className: "tab", "aria-selected": tab === key, "aria-controls": `panel-${key}`, tabIndex: tab === key ? 0 : -1, ref: (element) => {
+                        tabRefs.current[index] = element;
+                    }, onClick: () => {
+                        setTab(key);
+                    }, onKeyDown: onTabKeyDown }, t(`app.tab.${key}`)))))),
+            React.createElement("main", { className: "app-main" },
+                React.createElement("div", { className: "stack-lg" },
+                    hasNotices ? (React.createElement("div", { className: "stack" },
+                        notices.reset ? (React.createElement(Notice, { tone: "info", text: t("live.stream.reset"), onDismiss: () => {
+                                dismissNotice("reset");
+                            } })) : null,
+                        notices.missedFrames ? (React.createElement(Notice, { tone: "warning", text: t("app.missedFrames"), onDismiss: () => {
+                                dismissNotice("missedFrames");
+                            } })) : null)) : null,
+                    React.createElement("div", { role: "tabpanel", id: `panel-${tab}`, "aria-labelledby": `tab-${tab}`, tabIndex: 0 }, renderActiveTab()))),
+            React.createElement("footer", { className: "app-footer" },
+                React.createElement("span", { className: "mono-label" }, t("live.action.authorityLabel")),
+                React.createElement("p", null, t("live.action.authorityBody")),
+                React.createElement("p", { className: "footer-diagnostic" },
+                    t("live.metric.revision"),
+                    ":",
+                    " ",
+                    latest === undefined ? "—" : String(latest.streamRevision)))));
+    }
+    function App() {
+        const boot = window.EMBASSY_BOOT;
+        const [initialPrefs] = React.useState(() => loadPrefs(boot.locale));
+        return (React.createElement(Embassy.I18nProvider, { copy: boot.copy, initialLocale: initialPrefs.locale },
+            React.createElement(Shell, { initialTab: initialPrefs.tab })));
+    }
+    Embassy.App = App;
+    const rootElement = document.getElementById("root");
+    if (rootElement !== null) {
+        ReactDOM.createRoot(rootElement).render(React.createElement(App, null));
+    }
+})(Embassy || (Embassy = {}));