@nextop-os/browser-node 0.0.15 → 0.0.17

package/dist/chunk-XCKUTY7D.js

@@ -0,0 +1,852 @@
+import {
+  resolveBrowserSessionPartition
+} from "./chunk-OTK5YBCK.js";
+
+// src/react/BrowserNode.tsx
+import {
+  ArrowLeftIcon,
+  ArrowRightIcon,
+  Button,
+  LaunchIcon,
+  LoadingIcon,
+  RefreshIcon,
+  cn
+} from "@nextop-os/ui-system";
+
+// src/react/useBrowserNodeController.ts
+import { useEffect, useMemo } from "react";
+import { useExternalStoreSnapshot } from "@nextop-os/ui-react-hooks";
+
+// src/core/nodeController.ts
+var controllerRegistry = /* @__PURE__ */ new Map();
+function acquireBrowserNodeController(input) {
+  const existing = controllerRegistry.get(input.nodeId);
+  const entry = existing ?? createBrowserNodeControllerEntry({
+    defaultUrl: input.defaultUrl,
+    feature: input.feature,
+    nodeId: input.nodeId,
+    profileId: input.profileId ?? null,
+    sessionMode: input.sessionMode ?? "shared"
+  });
+  entry.context = {
+    defaultUrl: input.defaultUrl,
+    feature: input.feature,
+    nodeId: input.nodeId,
+    profileId: input.profileId ?? null,
+    sessionMode: input.sessionMode ?? "shared"
+  };
+  if (!existing) {
+    controllerRegistry.set(input.nodeId, entry);
+  }
+  reconcileBrowserNodeControllerState(entry, {
+    allowAutoActivate: false,
+    notifyListeners: false
+  });
+  return entry.controller;
+}
+function createBrowserNodeControllerEntry(context) {
+  const runtime = context.feature.runtimeStore.getNodeState(context.nodeId);
+  const displayUrl = resolveBrowserNodeDisplayUrl(runtime, context.defaultUrl);
+  const entry = {
+    connectedRelease: null,
+    controller: null,
+    context,
+    lastColdActivationUrl: null,
+    listeners: /* @__PURE__ */ new Set(),
+    pendingColdActivationUrl: null,
+    refCount: 0,
+    runtimeUnsubscribe: null,
+    state: {
+      displayUrl,
+      draftUrl: displayUrl,
+      runtime
+    }
+  };
+  entry.controller = {
+    getState() {
+      return entry.state;
+    },
+    goBack() {
+      return entry.context.feature.hostApi.goBack({
+        nodeId: entry.context.nodeId
+      });
+    },
+    goForward() {
+      return entry.context.feature.hostApi.goForward({
+        nodeId: entry.context.nodeId
+      });
+    },
+    reload() {
+      return entry.context.feature.hostApi.reload({
+        nodeId: entry.context.nodeId
+      });
+    },
+    release() {
+      entry.refCount = Math.max(0, entry.refCount - 1);
+      if (entry.refCount > 0) {
+        return;
+      }
+      entry.connectedRelease?.();
+      entry.connectedRelease = null;
+      entry.runtimeUnsubscribe?.();
+      entry.runtimeUnsubscribe = null;
+      controllerRegistry.delete(entry.context.nodeId);
+    },
+    retain() {
+      entry.refCount += 1;
+      if (entry.refCount > 1) {
+        return;
+      }
+      if (!controllerRegistry.has(entry.context.nodeId)) {
+        controllerRegistry.set(entry.context.nodeId, entry);
+      }
+      entry.connectedRelease = entry.context.feature.connect();
+      entry.runtimeUnsubscribe = entry.context.feature.runtimeStore.subscribe(
+        () => {
+          reconcileBrowserNodeControllerState(entry, {
+            allowAutoActivate: true,
+            notifyListeners: true
+          });
+        }
+      );
+      reconcileBrowserNodeControllerState(entry, {
+        allowAutoActivate: true,
+        notifyListeners: true
+      });
+    },
+    setDraftUrl(nextUrl) {
+      if (entry.state.draftUrl === nextUrl) {
+        return;
+      }
+      entry.state = {
+        ...entry.state,
+        draftUrl: nextUrl
+      };
+      notifyBrowserNodeControllerListeners(entry);
+    },
+    subscribe(listener) {
+      entry.listeners.add(listener);
+      return () => {
+        entry.listeners.delete(listener);
+      };
+    },
+    async submitDraftUrl() {
+      const resolved = entry.context.feature.resolveAddressInput(
+        entry.state.draftUrl
+      );
+      if (!resolved.url) {
+        return;
+      }
+      if (entry.state.draftUrl !== resolved.url) {
+        entry.state = {
+          ...entry.state,
+          draftUrl: resolved.url
+        };
+        notifyBrowserNodeControllerListeners(entry);
+      }
+      await entry.context.feature.hostApi.navigate({
+        nodeId: entry.context.nodeId,
+        url: resolved.url
+      });
+    }
+  };
+  return entry;
+}
+function notifyBrowserNodeControllerListeners(entry) {
+  for (const listener of entry.listeners) {
+    listener();
+  }
+}
+function resolveBrowserNodeDisplayUrl(runtime, defaultUrl) {
+  const resolvedRuntimeUrl = runtime.url?.trim() ?? "";
+  return resolvedRuntimeUrl.length > 0 ? resolvedRuntimeUrl : defaultUrl;
+}
+function reconcileBrowserNodeControllerState(entry, options) {
+  const runtime = entry.context.feature.runtimeStore.getNodeState(
+    entry.context.nodeId
+  );
+  const displayUrl = resolveBrowserNodeDisplayUrl(
+    runtime,
+    entry.context.defaultUrl
+  );
+  const nextDraftUrl = displayUrl !== entry.state.displayUrl ? displayUrl : entry.state.draftUrl;
+  const changed = entry.state.runtime !== runtime || entry.state.displayUrl !== displayUrl || entry.state.draftUrl !== nextDraftUrl;
+  if (changed) {
+    entry.state = {
+      displayUrl,
+      draftUrl: nextDraftUrl,
+      runtime
+    };
+    if (options.notifyListeners) {
+      notifyBrowserNodeControllerListeners(entry);
+    }
+  }
+  if (options.allowAutoActivate) {
+    void maybeActivateColdBrowserNode(entry).catch(() => void 0);
+  }
+}
+async function maybeActivateColdBrowserNode(entry) {
+  const { defaultUrl, feature, nodeId, profileId, sessionMode } = entry.context;
+  const trimmedUrl = defaultUrl.trim();
+  if (trimmedUrl.length === 0 || entry.state.runtime.lifecycle !== "cold" || entry.state.runtime.isLoading || entry.state.runtime.error !== null || entry.pendingColdActivationUrl === trimmedUrl || entry.lastColdActivationUrl === trimmedUrl) {
+    return;
+  }
+  entry.pendingColdActivationUrl = trimmedUrl;
+  try {
+    await feature.hostApi.activate({
+      nodeId,
+      profileId,
+      sessionMode,
+      url: trimmedUrl
+    });
+    entry.lastColdActivationUrl = trimmedUrl;
+  } finally {
+    if (entry.pendingColdActivationUrl === trimmedUrl) {
+      entry.pendingColdActivationUrl = null;
+    }
+  }
+}
+
+// src/react/useBrowserNodeController.ts
+function useBrowserNodeController(input) {
+  const controller = useMemo(
+    () => acquireBrowserNodeController({
+      defaultUrl: input.defaultUrl,
+      feature: input.feature,
+      nodeId: input.nodeId,
+      profileId: input.profileId ?? null,
+      sessionMode: input.sessionMode ?? "shared"
+    }),
+    [
+      input.defaultUrl,
+      input.feature,
+      input.nodeId,
+      input.profileId,
+      input.sessionMode
+    ]
+  );
+  useEffect(() => {
+    controller.retain();
+    return () => {
+      controller.release();
+    };
+  }, [controller]);
+  const state = useExternalStoreSnapshot({
+    getSnapshot() {
+      return controller.getState();
+    },
+    subscribe(listener) {
+      return controller.subscribe(listener);
+    }
+  });
+  return {
+    controller,
+    state
+  };
+}
+
+// src/react/useBrowserNodeWebview.ts
+import { useCallback, useEffect as useEffect2, useMemo as useMemo2 } from "react";
+import { useExternalStoreSnapshot as useExternalStoreSnapshot2 } from "@nextop-os/ui-react-hooks";
+
+// src/core/webviewController.ts
+var browserGuestUnregisterGraceMs = 250;
+var webviewControllerRegistry = /* @__PURE__ */ new Map();
+var pendingGuestIdsByNodeId = /* @__PURE__ */ new Map();
+var pendingUnregisterTimersByNodeId = /* @__PURE__ */ new Map();
+function acquireBrowserNodeWebviewController(input) {
+  const existing = webviewControllerRegistry.get(input.nodeId);
+  const entry = existing ?? createBrowserNodeWebviewControllerEntry({
+    feature: input.feature,
+    initialUrl: input.initialUrl,
+    lifecycle: input.lifecycle,
+    nodeId: input.nodeId,
+    onGuestInteraction: input.onGuestInteraction,
+    profileId: input.profileId,
+    sessionMode: input.sessionMode
+  });
+  entry.context = {
+    feature: input.feature,
+    initialUrl: input.initialUrl,
+    lifecycle: input.lifecycle,
+    nodeId: input.nodeId,
+    onGuestInteraction: input.onGuestInteraction,
+    profileId: input.profileId,
+    sessionMode: input.sessionMode
+  };
+  if (!existing) {
+    webviewControllerRegistry.set(input.nodeId, entry);
+  }
+  return entry.controller;
+}
+function createBrowserNodeWebviewControllerEntry(context) {
+  const state = resolveBrowserNodeWebviewControllerState(context);
+  const entry = {
+    attachedListeners: [],
+    context,
+    controller: null,
+    listeners: /* @__PURE__ */ new Set(),
+    refCount: 0,
+    registeredGuestId: null,
+    registeringGuestId: null,
+    state,
+    webview: null
+  };
+  entry.controller = {
+    getState() {
+      return entry.state;
+    },
+    release() {
+      entry.refCount = Math.max(0, entry.refCount - 1);
+      if (entry.refCount > 0) {
+        return;
+      }
+      scheduleBrowserNodeGuestUnregister(entry);
+      detachBrowserNodeWebview(entry);
+      webviewControllerRegistry.delete(entry.context.nodeId);
+    },
+    retain() {
+      entry.refCount += 1;
+      if (entry.refCount > 1) {
+        return;
+      }
+      reconcileBrowserNodeWebviewControllerState(entry, {
+        allowHostEffects: true,
+        notifyListeners: true,
+        rebindWebview: true
+      });
+    },
+    setWebview(element) {
+      if (entry.webview === element) {
+        return;
+      }
+      detachBrowserNodeWebview(entry);
+      entry.webview = element;
+      attachBrowserNodeWebview(entry);
+    },
+    sync() {
+      reconcileBrowserNodeWebviewControllerState(entry, {
+        allowHostEffects: true,
+        notifyListeners: true,
+        rebindWebview: true
+      });
+    },
+    subscribe(listener) {
+      entry.listeners.add(listener);
+      return () => {
+        entry.listeners.delete(listener);
+      };
+    }
+  };
+  return entry;
+}
+function resolveBrowserNodeWebviewControllerState(context) {
+  const webviewPartition = resolveBrowserSessionPartition({
+    profileId: context.profileId,
+    sessionMode: context.sessionMode
+  });
+  return {
+    shouldRenderWebview: context.lifecycle !== "cold",
+    webviewKey: `${context.nodeId}:${webviewPartition}`,
+    webviewPartition,
+    webviewSrc: resolveBrowserWebviewSrc(context.initialUrl)
+  };
+}
+function reconcileBrowserNodeWebviewControllerState(entry, options) {
+  const nextState = resolveBrowserNodeWebviewControllerState(entry.context);
+  const changed = entry.state.shouldRenderWebview !== nextState.shouldRenderWebview || entry.state.webviewKey !== nextState.webviewKey || entry.state.webviewPartition !== nextState.webviewPartition || entry.state.webviewSrc !== nextState.webviewSrc;
+  if (options.allowHostEffects) {
+    if (entry.context.lifecycle === "cold") {
+      scheduleBrowserNodeGuestUnregister(entry);
+    } else {
+      clearPendingBrowserNodeGuestUnregister(entry.context.nodeId);
+      void entry.context.feature.hostApi.prepareSession({
+        nodeId: entry.context.nodeId,
+        profileId: entry.context.profileId,
+        sessionMode: entry.context.sessionMode
+      }).catch(() => void 0);
+    }
+  }
+  if (!changed && !options.rebindWebview) {
+    return;
+  }
+  if (changed) {
+    entry.state = nextState;
+  }
+  detachBrowserNodeWebview(entry);
+  attachBrowserNodeWebview(entry);
+  if (changed && options.notifyListeners) {
+    notifyBrowserNodeWebviewControllerListeners(entry);
+  }
+}
+function resolveBrowserWebviewSrc(url) {
+  const trimmed = url.trim();
+  return trimmed.length > 0 ? trimmed : "about:blank";
+}
+function notifyBrowserNodeWebviewControllerListeners(entry) {
+  for (const listener of entry.listeners) {
+    listener();
+  }
+}
+function clearPendingBrowserNodeGuestUnregister(nodeId) {
+  const timerId = pendingUnregisterTimersByNodeId.get(nodeId);
+  if (timerId !== void 0) {
+    globalThis.clearTimeout(timerId);
+    pendingUnregisterTimersByNodeId.delete(nodeId);
+  }
+  pendingGuestIdsByNodeId.delete(nodeId);
+}
+function scheduleBrowserNodeGuestUnregister(entry) {
+  const guestId = entry.registeredGuestId;
+  const nodeId = entry.context.nodeId;
+  entry.registeringGuestId = null;
+  if (guestId === null) {
+    clearPendingBrowserNodeGuestUnregister(nodeId);
+    return;
+  }
+  entry.registeredGuestId = null;
+  clearPendingBrowserNodeGuestUnregister(nodeId);
+  pendingGuestIdsByNodeId.set(nodeId, guestId);
+  const timerId = globalThis.setTimeout(() => {
+    pendingUnregisterTimersByNodeId.delete(nodeId);
+    const pendingGuestId = pendingGuestIdsByNodeId.get(nodeId);
+    pendingGuestIdsByNodeId.delete(nodeId);
+    if (typeof pendingGuestId !== "number" || !Number.isFinite(pendingGuestId)) {
+      return;
+    }
+    void entry.context.feature.hostApi.unregisterGuest({
+      nodeId: entry.context.nodeId,
+      webContentsId: pendingGuestId
+    }).catch(() => void 0);
+  }, browserGuestUnregisterGraceMs);
+  pendingUnregisterTimersByNodeId.set(nodeId, timerId);
+}
+function detachBrowserNodeWebview(entry) {
+  if (!entry.webview) {
+    entry.attachedListeners = [];
+    return;
+  }
+  for (const record of entry.attachedListeners) {
+    entry.webview.removeEventListener(record.event, record.listener);
+  }
+  entry.attachedListeners = [];
+}
+function attachBrowserNodeWebview(entry) {
+  const webview = entry.webview;
+  if (!webview || !entry.state.shouldRenderWebview) {
+    return;
+  }
+  const registerGuest = async () => {
+    const guestId = webview.getWebContentsId?.();
+    if (typeof guestId !== "number" || !Number.isFinite(guestId) || guestId <= 0 || entry.registeredGuestId === guestId || entry.registeringGuestId === guestId) {
+      return;
+    }
+    clearPendingBrowserNodeGuestUnregister(entry.context.nodeId);
+    entry.registeringGuestId = guestId;
+    try {
+      await entry.context.feature.hostApi.registerGuest({
+        nodeId: entry.context.nodeId,
+        profileId: entry.context.profileId,
+        sessionMode: entry.context.sessionMode,
+        webContentsId: guestId
+      });
+      entry.registeredGuestId = guestId;
+    } finally {
+      if (entry.registeringGuestId === guestId) {
+        entry.registeringGuestId = null;
+      }
+    }
+  };
+  const handleDidAttach = () => {
+    void registerGuest().catch(() => void 0);
+  };
+  const handleDomReady = () => {
+    void registerGuest().catch(() => void 0);
+  };
+  const handleGuestInteraction = () => {
+    entry.context.onGuestInteraction?.();
+  };
+  const records = [
+    { event: "did-attach", listener: handleDidAttach },
+    { event: "dom-ready", listener: handleDomReady },
+    { event: "focus", listener: handleGuestInteraction },
+    { event: "ipc-message", listener: handleGuestInteraction }
+  ];
+  for (const record of records) {
+    webview.addEventListener(record.event, record.listener);
+  }
+  entry.attachedListeners = records;
+}
+
+// src/react/useBrowserNodeWebview.ts
+function useBrowserNodeWebview({
+  feature,
+  initialUrl,
+  lifecycle,
+  nodeId,
+  onGuestInteraction,
+  profileId,
+  sessionMode
+}) {
+  const controller = useMemo2(
+    () => acquireBrowserNodeWebviewController({
+      feature,
+      initialUrl,
+      lifecycle,
+      nodeId,
+      onGuestInteraction,
+      profileId,
+      sessionMode
+    }),
+    [
+      feature,
+      initialUrl,
+      lifecycle,
+      nodeId,
+      onGuestInteraction,
+      profileId,
+      sessionMode
+    ]
+  );
+  useEffect2(() => {
+    controller.retain();
+    return () => {
+      controller.release();
+    };
+  }, [controller]);
+  useEffect2(() => {
+    controller.sync();
+  }, [
+    controller,
+    initialUrl,
+    lifecycle,
+    nodeId,
+    onGuestInteraction,
+    profileId,
+    sessionMode
+  ]);
+  const state = useExternalStoreSnapshot2({
+    getSnapshot() {
+      return controller.getState();
+    },
+    subscribe(listener) {
+      return controller.subscribe(listener);
+    }
+  });
+  const setWebviewRef = useCallback(
+    (element) => {
+      controller.setWebview(element);
+    },
+    [controller]
+  );
+  return {
+    shouldRenderWebview: state.shouldRenderWebview,
+    setWebviewRef,
+    webviewKey: state.webviewKey,
+    webviewPartition: state.webviewPartition,
+    webviewSrc: state.webviewSrc
+  };
+}
+
+// src/react/BrowserNode.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function BrowserNode({
+  defaultUrl,
+  feature,
+  nodeId,
+  onFocusRequest,
+  profileId = null,
+  sessionMode = "shared",
+  showHeader = true
+}) {
+  const { controller, state } = useBrowserNodeController({
+    defaultUrl,
+    feature,
+    nodeId,
+    profileId,
+    sessionMode
+  });
+  const runtime = state.runtime;
+  const errorMessage = runtime.error ? formatBrowserNodeErrorMessage(feature, runtime.error) : null;
+  const {
+    shouldRenderWebview,
+    setWebviewRef,
+    webviewKey,
+    webviewPartition,
+    webviewSrc
+  } = useBrowserNodeWebview({
+    feature,
+    initialUrl: state.displayUrl,
+    lifecycle: runtime.lifecycle,
+    nodeId,
+    onGuestInteraction: onFocusRequest,
+    profileId,
+    sessionMode
+  });
+  return /* @__PURE__ */ jsxs("div", { className: "flex h-full min-h-0 flex-col overflow-hidden bg-background", children: [
+    showHeader ? /* @__PURE__ */ jsx(
+      BrowserNodeHeader,
+      {
+        canGoBack: runtime.canGoBack,
+        canGoForward: runtime.canGoForward,
+        draftUrl: state.draftUrl,
+        feature,
+        isCold: runtime.lifecycle === "cold",
+        isLoading: runtime.isLoading,
+        onDraftUrlChange: (nextUrl) => controller.setDraftUrl(nextUrl),
+        onFocusRequest,
+        onSubmitUrl: () => {
+          void controller.submitDraftUrl().catch(() => void 0);
+        },
+        onGoBack: () => {
+          void controller.goBack().catch(() => void 0);
+        },
+        onGoForward: () => {
+          void controller.goForward().catch(() => void 0);
+        },
+        onReload: () => {
+          void controller.reload().catch(() => void 0);
+        }
+      }
+    ) : null,
+    /* @__PURE__ */ jsxs("div", { className: "relative min-h-0 flex-1 overflow-hidden bg-background", children: [
+      shouldRenderWebview ? /* @__PURE__ */ jsx(
+        "webview",
+        {
+          ref: setWebviewRef,
+          className: "absolute inset-0 h-full w-full border-0 bg-background",
+          "data-browser-node-webview": "true",
+          partition: webviewPartition,
+          src: webviewSrc
+        },
+        webviewKey
+      ) : null,
+      errorMessage ? /* @__PURE__ */ jsx("div", { className: "pointer-events-none absolute inset-0 z-10 flex items-center justify-end p-3 text-center", children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: "max-w-[min(320px,100%)] rounded-md border border-border bg-card/95 px-3 py-2 text-sm text-card-foreground shadow-panel",
+          role: "status",
+          "aria-live": "polite",
+          children: [
+            /* @__PURE__ */ jsx("div", { className: "font-medium", children: feature.i18n.t("loadFailed") }),
+            /* @__PURE__ */ jsx("div", { className: "mt-1 text-xs text-muted-foreground", children: errorMessage })
+          ]
+        }
+      ) }) : null
+    ] })
+  ] });
+}
+function BrowserNodeWorkbenchHeader({
+  className,
+  defaultActions,
+  defaultUrl,
+  dragHandleProps,
+  feature,
+  nodeId,
+  onCloseRequest,
+  onFocusRequest
+}) {
+  const { controller, state } = useBrowserNodeController({
+    defaultUrl,
+    feature,
+    nodeId
+  });
+  const runtime = state.runtime;
+  return /* @__PURE__ */ jsx(
+    BrowserNodeHeader,
+    {
+      canGoBack: runtime.canGoBack,
+      canGoForward: runtime.canGoForward,
+      className,
+      defaultActions,
+      draftUrl: state.draftUrl,
+      dragHandleProps,
+      feature,
+      isCold: runtime.lifecycle === "cold",
+      isLoading: runtime.isLoading,
+      onCloseRequest,
+      onDraftUrlChange: (nextUrl) => controller.setDraftUrl(nextUrl),
+      onFocusRequest,
+      onSubmitUrl: () => {
+        void controller.submitDraftUrl().catch(() => void 0);
+      },
+      onGoBack: () => {
+        void controller.goBack().catch(() => void 0);
+      },
+      onGoForward: () => {
+        void controller.goForward().catch(() => void 0);
+      },
+      onReload: () => {
+        void controller.reload().catch(() => void 0);
+      },
+      withBorder: false
+    }
+  );
+}
+function BrowserNodeHeader({
+  canGoBack,
+  canGoForward,
+  className,
+  defaultActions,
+  draftUrl,
+  dragHandleProps,
+  feature,
+  isCold = false,
+  isLoading,
+  onCloseRequest,
+  onDraftUrlChange,
+  onFocusRequest,
+  onGoBack,
+  onGoForward,
+  onReload,
+  onSubmitUrl,
+  withBorder = true
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "flex h-[var(--workbench-header-height,38px)] min-h-[var(--workbench-header-height,38px)] items-center gap-2 bg-[var(--workbench-window-header-bg)] px-2 pl-3",
+        withBorder ? "border-b border-border" : null,
+        className
+      ),
+      "data-browser-node-header": "true",
+      onDoubleClick: (event) => {
+        if (event.target instanceof Element && event.target.closest(".nodrag")) {
+          return;
+        }
+        event.stopPropagation();
+        dragHandleProps?.onDoubleClick?.(event);
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ jsx(
+            BrowserNodeHeaderButton,
+            {
+              disabled: !canGoBack,
+              label: feature.i18n.t("actions.back"),
+              onClick: onGoBack,
+              children: /* @__PURE__ */ jsx(ArrowLeftIcon, { className: "size-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            BrowserNodeHeaderButton,
+            {
+              disabled: !canGoForward,
+              label: feature.i18n.t("actions.forward"),
+              onClick: onGoForward,
+              children: /* @__PURE__ */ jsx(ArrowRightIcon, { className: "size-4" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            BrowserNodeHeaderButton,
+            {
+              label: feature.i18n.t("actions.reload"),
+              onClick: onReload,
+              children: /* @__PURE__ */ jsx(RefreshIcon, { className: "size-4" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            ...dragHandleProps,
+            className: "h-full w-8 shrink-0 cursor-grab active:cursor-grabbing",
+            "data-browser-node-drag-gutter": "true",
+            "data-node-drag-handle": "true",
+            "aria-hidden": "true"
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "form",
+          {
+            className: "nodrag flex h-8 min-h-8 min-w-0 flex-1 items-center gap-1.5 rounded-md border border-border bg-[var(--workbench-field-bg)] px-2 focus-within:ring-2 focus-within:ring-ring/60",
+            onSubmit: (event) => {
+              event.preventDefault();
+              event.stopPropagation();
+              onSubmitUrl();
+            },
+            children: [
+              /* @__PURE__ */ jsx(LaunchIcon, { className: "size-4 shrink-0 text-muted-foreground" }),
+              /* @__PURE__ */ jsx(
+                "input",
+                {
+                  "aria-label": feature.i18n.t("addressLabel"),
+                  className: "h-full min-w-0 flex-1 border-0 bg-transparent text-[13px] leading-none text-foreground outline-none placeholder:text-muted-foreground",
+                  placeholder: feature.i18n.t("addressPlaceholder"),
+                  value: draftUrl,
+                  onChange: (event) => onDraftUrlChange(event.target.value),
+                  onFocus: onFocusRequest
+                }
+              ),
+              isLoading ? /* @__PURE__ */ jsx(LoadingIcon, { className: "size-4 shrink-0 animate-spin text-muted-foreground" }) : null
+            ]
+          }
+        ),
+        defaultActions ? /* @__PURE__ */ jsxs("div", { className: "nodrag flex shrink-0 items-center gap-1.5", children: [
+          isCold ? /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "inline-flex h-[26px] min-w-7 items-center justify-center rounded-md bg-muted/80 px-2 text-[10px] font-semibold lowercase tracking-[0.08em] text-muted-foreground",
+              "aria-label": feature.i18n.t("coldStatus"),
+              children: feature.i18n.t("coldStatus")
+            }
+          ) : null,
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "contents",
+              onClickCapture: (event) => {
+                if (!onCloseRequest || !(event.target instanceof Element) || !event.target.closest('[data-workbench-action="close"]')) {
+                  return;
+                }
+                onCloseRequest();
+              },
+              children: defaultActions
+            }
+          )
+        ] }) : null
+      ]
+    }
+  );
+}
+function formatBrowserNodeErrorMessage(feature, error) {
+  switch (error.code) {
+    case "invalid-url":
+      return feature.i18n.t("errors.invalidUrl", error.params);
+    case "navigation-failed":
+      return feature.i18n.t("errors.navigationFailed", error.params);
+    case "unsupported-protocol":
+      return feature.i18n.t("errors.unsupportedProtocol", error.params);
+    case "unsupported-url":
+      return feature.i18n.t("errors.unsupportedUrl", error.params);
+  }
+}
+function BrowserNodeHeaderButton({
+  children,
+  disabled,
+  label,
+  onClick
+}) {
+  return /* @__PURE__ */ jsx(
+    Button,
+    {
+      "aria-label": label,
+      className: "rounded-md",
+      disabled,
+      size: "icon",
+      title: label,
+      type: "button",
+      variant: "chrome",
+      onClick,
+      children
+    }
+  );
+}
+
+export {
+  BrowserNode,
+  BrowserNodeWorkbenchHeader,
+  BrowserNodeHeader
+};
+//# sourceMappingURL=chunk-XCKUTY7D.js.map