fluxplugin 1.0.0

package/dist/browser/chunks/chunk-ZZ25CRMR.js

@@ -0,0 +1,759 @@
+import {
+  MGMT,
+  PermissionManager,
+  PluginManager,
+  errorMessage,
+  normalizePath,
+  scopeCss
+} from "./chunk-Q75AOCXD.js";
+
+// src/react/runtime.ts
+var RemoteError = class extends Error {
+  constructor(payload) {
+    super(payload.message);
+    this.payload = payload;
+    this.name = "RemoteError";
+  }
+  payload;
+  get code() {
+    return this.payload.code;
+  }
+};
+var PluginsClient = class {
+  constructor(bridge) {
+    this.bridge = bridge;
+  }
+  bridge;
+  call(channel, input) {
+    return this.bridge.invoke(channel, input);
+  }
+  list = () => this.call(MGMT.list);
+  enable = (id) => this.call(MGMT.enable, { id });
+  disable = (id) => this.call(MGMT.disable, { id });
+  reload = (id) => this.call(MGMT.reload, { id });
+  grant = (id, permission) => this.call(MGMT.grant, { id, permission });
+  revoke = (id, permission) => this.call(MGMT.revoke, { id, permission });
+  uninstall = (id) => this.call(MGMT.uninstall, { id });
+  search = (query) => this.call(MGMT.search, { query });
+  updates = () => this.call(MGMT.updates);
+  install = (entry) => this.call(MGMT.install, { entry });
+  update = (entry) => this.call(MGMT.update, { entry });
+  rollback = (id, version) => this.call(MGMT.rollback, { id, version });
+  configGet = (id) => this.call(MGMT.configGet, { id });
+  configSet = (id, patch) => this.call(MGMT.configSet, { id, patch });
+  configReset = (id) => this.call(MGMT.configReset, { id });
+  configSchema = (id) => this.call(MGMT.configSchema, { id });
+  logs = (id) => this.call(MGMT.logs, { id });
+  diagnostics = (id) => this.call(MGMT.diagnostics, { id });
+};
+var asDefinition = (mod) => {
+  const d = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+  if (!d || typeof d !== "object") throw new Error("renderer entry must default-export definePlugin({...})");
+  return d;
+};
+var RendererFramework = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.bridge = opts.bridge;
+    this.client = new PluginsClient(opts.bridge);
+    this.manager = new PluginManager({
+      runtime: "renderer",
+      permissions: this.permissions,
+      ipcBridge: {
+        invoke: (name, input, caller) => opts.bridge.invoke(name, input, caller),
+        send: (channel, payload, caller) => opts.bridge.send(channel, payload, caller),
+        on: (channel, fn) => ({ dispose: opts.bridge.on(channel, fn) })
+      },
+      // Renderer plugins that crash must never take the app down; the main side persists auto-disable.
+      ...opts.manager
+    });
+    this.manager.subscribe(() => this.touch());
+  }
+  opts;
+  bridge;
+  client;
+  manager;
+  permissions = new PermissionManager({ autoGrant: false });
+  revision = -1;
+  bootstrap;
+  syncing = Promise.resolve();
+  renderErrors = /* @__PURE__ */ new Map();
+  unsubscribers = [];
+  storeListeners = /* @__PURE__ */ new Set();
+  _storeVersion = 0;
+  /** `useSyncExternalStore` plumbing for the bootstrap-derived view (plugin list etc.). */
+  get storeVersion() {
+    return this._storeVersion + this.manager.version;
+  }
+  subscribe = (l) => {
+    this.storeListeners.add(l);
+    const off = this.manager.subscribe(l);
+    return () => {
+      this.storeListeners.delete(l);
+      off();
+    };
+  };
+  touch() {
+    this._storeVersion++;
+    for (const l of [...this.storeListeners]) l();
+  }
+  get currentBootstrap() {
+    return this.bootstrap;
+  }
+  /** Fetches the bootstrap, activates enabled plugins and starts listening for changes. */
+  async start() {
+    await this.sync();
+    this.unsubscribers.push(
+      this.bridge.on(MGMT.changed, () => {
+        void this.sync().catch((e) => console.error("[fluxplugin] sync failed", e));
+      }),
+      this.bridge.on("flux.event.plugin.hotreload", ({ id } = {}) => void this.hotReload(id))
+    );
+  }
+  stop() {
+    for (const u of this.unsubscribers.splice(0)) u();
+  }
+  hotReload(id) {
+    this.cacheBust = Date.now();
+    return this.sync(true).then(async () => {
+      if (id && this.manager.has(id)) await this.manager.reload(id).catch(() => void 0);
+    });
+  }
+  cacheBust = 0;
+  /** Mirrors main-process state into the renderer manager. Calls are serialized. */
+  sync(force = false) {
+    const run = this.syncing.then(async () => {
+      const boot = await this.bridge.bootstrap();
+      if (!force && boot.revision === this.revision && this.bootstrap) return;
+      this.revision = boot.revision;
+      this.bootstrap = boot;
+      await this.reconcile(boot);
+      this.installWindowPlugins(boot.preload);
+      this.touch();
+    });
+    this.syncing = run.catch(() => void 0);
+    return run;
+  }
+  async reconcile(boot) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const d of boot.plugins) {
+      seen.add(d.id);
+      this.permissions.restore({ [d.id]: d.granted });
+      if (!this.manager.has(d.id)) {
+        if (d.state === "error" && !d.rendererUrl) continue;
+        this.manager.register({ manifest: d.manifest, origin: "renderer", load: () => this.load(d) });
+        this.permissions.restore({ [d.id]: d.granted });
+      } else {
+        this.permissions.restore({ [d.id]: d.granted });
+      }
+      const info = this.manager.info(d.id);
+      if (!d.enabled && info.enabled) await this.manager.disable(d.id).catch(() => void 0);
+      else if (d.enabled && !info.enabled) await this.manager.enable(d.id, { activate: false }).catch(() => void 0);
+    }
+    for (const info of this.manager.list()) if (!seen.has(info.id)) await this.manager.unregister(info.id);
+    await this.manager.startup();
+  }
+  async load(d) {
+    let def = {};
+    if (d.rendererUrl) {
+      const url = this.cacheBust ? `${d.rendererUrl}${d.rendererUrl.includes("?") ? "&" : "?"}flux=${this.cacheBust}` : d.rendererUrl;
+      const mod = await (this.opts.importPlugin ? this.opts.importPlugin(url, d) : import(
+        /* @vite-ignore */
+        url
+      ));
+      def = asDefinition(mod);
+    }
+    const hrefs = d.styleUrls;
+    if (!hrefs.length) return def;
+    const activate = def.onActivate ?? def.activate;
+    return {
+      ...def,
+      onActivate: async (ctx) => {
+        hrefs.forEach((href, i) => ctx.lifecycle.subscriptions.add(this.manager.styles.register({ id: `manifest-${i}`, href, priority: 50 }, ctx.pluginId)));
+        await activate?.(ctx);
+      },
+      activate: void 0
+    };
+  }
+  /** Called by plugin error boundaries. Repeated render failures disable the plugin. */
+  reportRenderError(pluginId, error) {
+    this.manager.logs.logger(pluginId).error(`render error: ${errorMessage(error)}`, error instanceof Error ? error.stack : void 0);
+    const now = Date.now();
+    const list = [...(this.renderErrors.get(pluginId) ?? []).filter((t) => now - t < 6e4), now];
+    this.renderErrors.set(pluginId, list);
+    if (list.length >= (this.opts.maxRenderErrors ?? 3) && this.manager.has(pluginId) && this.manager.info(pluginId).enabled) {
+      this.manager.logs.logger(pluginId).warn("disabled automatically after repeated render errors");
+      this.renderErrors.delete(pluginId);
+      void this.client.disable(pluginId).catch(() => this.manager.disable(pluginId));
+    }
+  }
+  /** Builds `window.plugins.<ns>.<member>` from the preload manifest. Rebuilt on every sync. */
+  installWindowPlugins(spec) {
+    if (typeof window === "undefined") return;
+    window.plugins = buildPluginApis(this.bridge, spec);
+  }
+  /** Config handle usable from React (mirrors ctx.config through the management API). */
+  configOf(id) {
+    return {
+      get: () => this.client.configGet(id),
+      set: (p) => this.client.configSet(id, p),
+      reset: () => this.client.configReset(id)
+    };
+  }
+};
+function buildPluginApis(bridge, spec) {
+  const out = {};
+  for (const [ns, members] of Object.entries(spec)) {
+    const api = /* @__PURE__ */ Object.create(null);
+    for (const [name, m] of Object.entries(members)) {
+      if (m.kind === "invoke") api[name] = (input) => bridge.invoke(m.channel, input, ns);
+      else if (m.kind === "send") api[name] = (payload) => bridge.send(m.channel, payload, ns);
+      else api[name] = (listener) => bridge.on(m.channel, listener);
+    }
+    out[ns] = Object.freeze(api);
+  }
+  return Object.freeze(out);
+}
+function installSharedModules(modules) {
+  const g = globalThis;
+  g.__FLUXPLUGIN_SHARED__ = { ...g.__FLUXPLUGIN_SHARED__ ?? {}, ...modules };
+}
+
+// src/react/components.tsx
+import {
+  Component,
+  createContext,
+  useCallback as useCallback2,
+  useContext,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef,
+  useState as useState2,
+  useSyncExternalStore as useSyncExternalStore2
+} from "react";
+
+// src/react/router.tsx
+import {
+  Suspense,
+  lazy,
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+  useSyncExternalStore
+} from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function currentPath() {
+  if (typeof window === "undefined") return "/";
+  const h = window.location.hash.replace(/^#/, "");
+  return normalizePath(h || "/");
+}
+var listeners = /* @__PURE__ */ new Set();
+if (typeof window !== "undefined") window.addEventListener("hashchange", () => listeners.forEach((l) => l()));
+var subscribeLocation = (l) => (listeners.add(l), () => void listeners.delete(l));
+function navigate(to, opts = {}) {
+  const target = "#" + normalizePath(to) + (to.includes("?") ? "?" + to.split("?")[1] : "");
+  if (opts.replace) window.location.replace(target);
+  else window.location.hash = target;
+  listeners.forEach((l) => l());
+}
+function useLocation() {
+  return useSyncExternalStore(subscribeLocation, currentPath, () => "/");
+}
+function useNavigate() {
+  return navigate;
+}
+function Link({ to, children, ...rest }) {
+  const here = useLocation();
+  const active = here === normalizePath(to) || to !== "/" && here.startsWith(normalizePath(to) + "/");
+  return /* @__PURE__ */ jsx("a", { ...rest, href: "#" + normalizePath(to), "data-active": active || void 0, "aria-current": active ? "page" : void 0, children });
+}
+function usePluginRoute() {
+  const fw = usePluginFramework();
+  const path = useLocation();
+  const routes = fw.manager.routes;
+  const version = useSyncExternalStore(routes.subscribe, () => routes.version, () => routes.version);
+  return useMemo(() => {
+    const match = routes.match(path);
+    return { match, params: match?.params ?? {}, breadcrumbs: match ? routes.breadcrumbs(match) : [], path };
+  }, [routes, path, version]);
+}
+var useParams = () => usePluginRoute().params;
+function Breadcrumbs({ separator = "/" }) {
+  const { breadcrumbs } = usePluginRoute();
+  if (!breadcrumbs.length) return null;
+  return /* @__PURE__ */ jsx("nav", { "aria-label": "Breadcrumb", className: "flux-breadcrumbs", children: breadcrumbs.map((b, i) => /* @__PURE__ */ jsxs("span", { children: [
+    i > 0 && /* @__PURE__ */ jsxs("span", { className: "flux-breadcrumb-sep", children: [
+      " ",
+      separator,
+      " "
+    ] }),
+    i === breadcrumbs.length - 1 ? /* @__PURE__ */ jsx("span", { "aria-current": "page", children: b.label }) : /* @__PURE__ */ jsx(Link, { to: b.path, children: b.label })
+  ] }, b.path)) });
+}
+var lazyCache = /* @__PURE__ */ new WeakMap();
+function resolveComponent(def) {
+  if (def.component) return def.component;
+  const loader = def.lazy;
+  let c = lazyCache.get(loader);
+  if (!c) {
+    c = lazy(async () => {
+      const mod = await loader();
+      const comp = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+      return { default: comp };
+    });
+    lazyCache.set(loader, c);
+  }
+  return c;
+}
+function PluginRoutes({ notFound, forbidden, loading, defaultLayout: DefaultLayout }) {
+  const fw = usePluginFramework();
+  const path = useLocation();
+  const routes = fw.manager.routes;
+  useSyncExternalStore(routes.subscribe, () => routes.version, () => routes.version);
+  const [resolution, setResolution] = useState(null);
+  const version = routes.version;
+  useEffect(() => {
+    let live = true;
+    (async () => {
+      const match2 = await routes.matchAsync(path);
+      if (!match2) return live && setResolution({ path });
+      const guard2 = await routes.checkGuards(match2, path);
+      if (live) setResolution({ path, match: match2, guard: guard2 });
+    })().catch(() => live && setResolution({ path }));
+    return () => {
+      live = false;
+    };
+  }, [routes, path, version]);
+  useEffect(() => {
+    if (resolution?.path === path && resolution.guard && !resolution.guard.allow && resolution.guard.redirect) navigate(resolution.guard.redirect, { replace: true });
+  }, [resolution, path]);
+  if (!resolution || resolution.path !== path) return /* @__PURE__ */ jsx(Fragment, { children: loading ?? null });
+  const { match, guard } = resolution;
+  if (!match) return /* @__PURE__ */ jsx(Fragment, { children: notFound ?? /* @__PURE__ */ jsxs("div", { className: "flux-not-found", children: [
+    "Page not found: ",
+    path
+  ] }) });
+  if (guard && !guard.allow) {
+    if (guard.redirect) return /* @__PURE__ */ jsx(Fragment, { children: loading ?? null });
+    return /* @__PURE__ */ jsx(Fragment, { children: forbidden ? forbidden(guard.reason) : /* @__PURE__ */ jsxs("div", { className: "flux-forbidden", children: [
+      "Access denied: ",
+      guard.reason
+    ] }) });
+  }
+  const owner = match.route.owner ?? "host";
+  const Page = resolveComponent(match.route.definition);
+  let node = /* @__PURE__ */ jsx(Page, { params: match.params });
+  for (const r of [...match.chain].reverse()) {
+    const l = r.definition.layout;
+    if (!l) continue;
+    const Layout = typeof l === "string" ? routes.getLayout(l) : l;
+    if (Layout) node = /* @__PURE__ */ jsx(Layout, { children: node });
+  }
+  if (!match.chain.some((r) => r.definition.layout) && DefaultLayout) node = /* @__PURE__ */ jsx(DefaultLayout, { children: node });
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(PluginBoundary, { owner, children: /* @__PURE__ */ jsx(Suspense, { fallback: loading ?? /* @__PURE__ */ jsx("div", { className: "flux-loading", children: "Loading\u2026" }), children: node }) }, match.route.fullPath) });
+}
+function useMenu(location) {
+  const fw = usePluginFramework();
+  const menus = fw.manager.menus;
+  useSyncExternalStore(menus.subscribe, () => menus.version, () => menus.version);
+  const run = useCallback(
+    (item) => {
+      if (item.command) return fw.manager.commands.execute(item.command, ...item.args ?? []);
+      if (item.path) navigate(item.path);
+    },
+    [fw]
+  );
+  return { items: menus.items(location), run };
+}
+
+// src/react/components.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FrameworkContext = createContext(null);
+function PluginProvider({ framework, children }) {
+  return /* @__PURE__ */ jsx2(FrameworkContext.Provider, { value: framework, children });
+}
+function usePluginFramework() {
+  const fw = useContext(FrameworkContext);
+  if (!fw) throw new Error("usePlugin* hooks must be used inside <PluginProvider>");
+  return fw;
+}
+var PluginErrorBoundary = class extends Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, _info) {
+    this.props.framework.reportRenderError(this.props.owner, error);
+  }
+  reset = () => this.setState({ error: null });
+  render() {
+    const { error } = this.state;
+    if (!error) return this.props.children;
+    if (this.props.fallback) return this.props.fallback(error, this.reset);
+    return /* @__PURE__ */ jsxs2("div", { role: "alert", className: "fluxplugin-error", "data-flux-error": this.props.owner, children: [
+      /* @__PURE__ */ jsx2("strong", { children: this.props.owner }),
+      " failed to render.",
+      " ",
+      /* @__PURE__ */ jsx2("button", { type: "button", onClick: this.reset, children: "Retry" })
+    ] });
+  }
+};
+function PluginBoundary({ owner, children }) {
+  const fw = usePluginFramework();
+  return /* @__PURE__ */ jsx2("div", { "data-fluxplugin": owner, style: { display: "contents" }, children: /* @__PURE__ */ jsx2(PluginErrorBoundary, { owner, framework: fw, children }) });
+}
+function useRegistryVersion(subscribe, version) {
+  return useSyncExternalStore2(subscribe, version, version);
+}
+function renderContribution(c, props) {
+  const C = c.component;
+  return /* @__PURE__ */ jsx2(PluginBoundary, { owner: c.owner ?? "unknown", children: /* @__PURE__ */ jsx2(C, { ...c.props ?? {}, ...props }) }, c.id);
+}
+function PluginSlot({ name, children, props = {} }) {
+  const fw = usePluginFramework();
+  useRegistryVersion(fw.manager.slots.subscribe, () => fw.manager.slots.version);
+  const resolved = fw.manager.slots.resolve(name, props);
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    resolved.before.map((c) => renderContribution(c, props)),
+    resolved.replacement ? renderContribution(resolved.replacement, { ...props, children }) : children,
+    resolved.after.map((c) => renderContribution(c, props))
+  ] });
+}
+function useExtensionItems(point, key) {
+  const fw = usePluginFramework();
+  useRegistryVersion(fw.manager.extensionPoints.subscribe, () => fw.manager.extensionPoints.version);
+  return fw.manager.extensionPoints.items(point, key);
+}
+function usePlugin(id) {
+  const fw = usePluginFramework();
+  useRegistryVersion(fw.subscribe, () => fw.storeVersion);
+  return fw.manager.has(id) ? fw.manager.info(id) : void 0;
+}
+function usePlugins() {
+  const fw = usePluginFramework();
+  useRegistryVersion(fw.subscribe, () => fw.storeVersion);
+  return fw.manager.list();
+}
+function usePluginState(pluginId, key, initial) {
+  const fw = usePluginFramework();
+  const store = fw.manager.stateOf(pluginId);
+  const sub = useCallback2((l) => store.subscribe(l, key).dispose, [store, key]);
+  const value = useSyncExternalStore2(
+    sub,
+    () => store.get(key, initial),
+    () => initial
+  );
+  const set = useCallback2((v) => store.set(key, typeof v === "function" ? v(store.get(key, initial)) : v), [store, key, initial]);
+  return [value, set];
+}
+function usePluginEvent(name, onEvent) {
+  const fw = usePluginFramework();
+  const [last, setLast] = useState2(void 0);
+  const cb = useRef(onEvent);
+  cb.current = onEvent;
+  useEffect2(() => {
+    const handle = (p) => {
+      setLast(p);
+      cb.current?.(p);
+    };
+    const subs = [fw.manager.events.on(name, (p) => handle(p)), fw.bridge.on(name, handle), fw.bridge.on(`flux.event.${name}`, handle)];
+    return () => {
+      subs.forEach((s) => typeof s === "function" ? s() : s.dispose());
+    };
+  }, [fw, name]);
+  return last;
+}
+function usePluginCommand(id) {
+  const fw = usePluginFramework();
+  useRegistryVersion(fw.manager.commands.subscribe, () => fw.manager.commands.version);
+  const cmd = fw.manager.commands.get(id);
+  const run = useCallback2((...args) => fw.manager.commands.execute(id, ...args), [fw, id]);
+  return { run, available: !!cmd && (!cmd.when || cmd.when()), title: cmd?.title };
+}
+function usePluginService(name) {
+  const fw = usePluginFramework();
+  useRegistryVersion(fw.manager.services.subscribe, () => fw.manager.services.version);
+  useEffect2(() => {
+    if (!fw.manager.services.has(name)) void fw.manager.services.resolveAsync(name).catch(() => void 0);
+  }, [fw, name]);
+  return fw.manager.services.resolve(name);
+}
+function usePluginIPC(endpoint, opts = {}) {
+  const fw = usePluginFramework();
+  const name = typeof endpoint === "string" ? endpoint : endpoint.name;
+  const [state, setState] = useState2({ data: void 0, error: void 0, loading: false });
+  const alive = useRef(true);
+  useEffect2(() => () => void (alive.current = false), []);
+  const call = useCallback2(
+    async (input) => {
+      setState((s) => ({ ...s, loading: true, error: void 0 }));
+      try {
+        const data = await fw.bridge.invoke(name, input, opts.caller);
+        if (alive.current) setState({ data, error: void 0, loading: false });
+        return data;
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(String(e));
+        if (alive.current) setState({ data: void 0, error, loading: false });
+        throw error;
+      }
+    },
+    [fw, name, opts.caller]
+  );
+  return { ...state, call };
+}
+function usePluginConfig(pluginId) {
+  const fw = usePluginFramework();
+  const handle = useMemo2(() => fw.configOf(pluginId), [fw, pluginId]);
+  const [config, setConfig] = useState2();
+  const [error, setError] = useState2();
+  const [loading, setLoading] = useState2(true);
+  useEffect2(() => {
+    let live = true;
+    setLoading(true);
+    handle.get().then((c) => live && (setConfig(c), setError(void 0))).catch((e) => live && setError(e)).finally(() => live && setLoading(false));
+    const sub = fw.manager.events.on("plugin.config.changed", (p) => {
+      if (p?.id === pluginId) setConfig(p.next);
+    });
+    return () => {
+      live = false;
+      sub.dispose();
+    };
+  }, [fw, handle, pluginId]);
+  return {
+    config,
+    loading,
+    error,
+    set: async (patch) => {
+      const next = await handle.set(patch);
+      setConfig(next);
+      return next;
+    },
+    reset: async () => {
+      const next = await handle.reset();
+      setConfig(next);
+      return next;
+    }
+  };
+}
+function StyleHost() {
+  const fw = usePluginFramework();
+  useRegistryVersion(fw.manager.styles.subscribe, () => fw.manager.styles.version);
+  const entries = fw.manager.styles.ordered();
+  const sig = entries.map((e) => `${e.owner}/${e.id}/${e.priority}/${e.css?.length ?? 0}/${e.href ?? ""}`).join("|");
+  useEffect2(() => {
+    const created = [];
+    for (const e of entries) {
+      let el;
+      if (e.href) {
+        const link = document.createElement("link");
+        link.rel = "stylesheet";
+        link.href = e.href;
+        el = link;
+      } else {
+        const style = document.createElement("style");
+        style.textContent = e.scoped ? scopeCss(e.css ?? "", e.owner) : e.css ?? "";
+        el = style;
+      }
+      el.setAttribute("data-flux-style", `${e.owner}:${e.id}`);
+      document.head.appendChild(el);
+      created.push(el);
+    }
+    return () => created.forEach((el) => el.remove());
+  }, [sig]);
+  return null;
+}
+
+// src/react/palette.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2, useState as useState3, useSyncExternalStore as useSyncExternalStore3 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function useKeybindings(opts = {}) {
+  const fw = usePluginFramework();
+  useEffect3(() => {
+    if (opts.enabled === false) return;
+    const onKey = (e) => {
+      const target = e.target;
+      if (target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable) && !(e.ctrlKey || e.metaKey)) return;
+      const parts = [];
+      if (e.ctrlKey || e.metaKey) parts.push("mod");
+      if (e.shiftKey) parts.push("shift");
+      if (e.altKey) parts.push("alt");
+      const key = e.key.toLowerCase();
+      if (["control", "shift", "alt", "meta"].includes(key)) return;
+      parts.push(key);
+      const cmd = fw.manager.commands.byKeybinding(parts.join("+"));
+      if (cmd) {
+        e.preventDefault();
+        void fw.manager.commands.execute(cmd.id).catch((err) => fw.manager.logs.logger("host").error(`command ${cmd.id} failed: ${String(err)}`));
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [fw, opts.enabled]);
+}
+function CommandPalette({ open, onClose }) {
+  const fw = usePluginFramework();
+  const cmds = fw.manager.commands;
+  useSyncExternalStore3(cmds.subscribe, () => cmds.version, () => cmds.version);
+  const [internal, setInternal] = useState3(false);
+  const isOpen = open ?? internal;
+  const close = () => onClose ? onClose() : setInternal(false);
+  const [query, setQuery] = useState3("");
+  const [index, setIndex] = useState3(0);
+  const input = useRef2(null);
+  useEffect3(() => {
+    const onKey = (e) => {
+      if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === "k") {
+        e.preventDefault();
+        setInternal((v) => !v);
+      } else if (e.key === "Escape") close();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+  useEffect3(() => {
+    if (isOpen) {
+      setQuery("");
+      setIndex(0);
+      setTimeout(() => input.current?.focus(), 0);
+    }
+  }, [isOpen]);
+  const results = useMemo3(() => cmds.palette(query), [cmds, query, cmds.version]);
+  if (!isOpen) return null;
+  const run = (i) => {
+    const c = results[i];
+    if (!c) return;
+    close();
+    void cmds.execute(c.id).catch((e) => fw.manager.logs.logger("host").error(String(e)));
+  };
+  return /* @__PURE__ */ jsx3("div", { className: "flux-palette-backdrop", onMouseDown: close, role: "presentation", children: /* @__PURE__ */ jsxs3("div", { className: "flux-palette", role: "dialog", "aria-label": "Command palette", onMouseDown: (e) => e.stopPropagation(), children: [
+    /* @__PURE__ */ jsx3(
+      "input",
+      {
+        ref: input,
+        className: "flux-palette-input",
+        placeholder: "Type a command\u2026",
+        value: query,
+        onChange: (e) => (setQuery(e.target.value), setIndex(0)),
+        onKeyDown: (e) => {
+          if (e.key === "ArrowDown") e.preventDefault(), setIndex((i) => Math.min(i + 1, results.length - 1));
+          else if (e.key === "ArrowUp") e.preventDefault(), setIndex((i) => Math.max(i - 1, 0));
+          else if (e.key === "Enter") run(index);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs3("ul", { className: "flux-palette-list", role: "listbox", children: [
+      results.length === 0 && /* @__PURE__ */ jsx3("li", { className: "flux-palette-empty", children: "No matching commands" }),
+      results.map((c, i) => /* @__PURE__ */ jsxs3("li", { role: "option", "aria-selected": i === index, className: "flux-palette-item" + (i === index ? " is-active" : ""), onMouseEnter: () => setIndex(i), onClick: () => run(i), children: [
+        /* @__PURE__ */ jsxs3("span", { children: [
+          c.category && /* @__PURE__ */ jsxs3("span", { className: "flux-palette-cat", children: [
+            c.category,
+            ": "
+          ] }),
+          c.title
+        ] }),
+        c.keybinding && /* @__PURE__ */ jsx3("kbd", { children: c.keybinding.replace("Mod", /Mac/.test(navigator.platform) ? "\u2318" : "Ctrl") })
+      ] }, c.id))
+    ] })
+  ] }) });
+}
+
+// src/react/base-css.ts
+var baseCss = `
+:root{--flux-bg:#fff;--flux-fg:#0f172a;--flux-muted:#64748b;--flux-border:#e2e8f0;--flux-accent:#4f46e5;--flux-accent-fg:#fff;--flux-surface:#f8fafc;--flux-danger:#dc2626;--flux-ok:#16a34a;--flux-warn:#d97706;--flux-radius:10px}
+@media (prefers-color-scheme: dark){:root:not([data-theme="light"]){--flux-bg:#0b1020;--flux-fg:#e5e7eb;--flux-muted:#94a3b8;--flux-border:#1f2a44;--flux-surface:#111936}}
+.fluxplugin-error{padding:8px 12px;border:1px solid var(--flux-danger);border-radius:var(--flux-radius);color:var(--flux-danger);font-size:13px}
+.flux-breadcrumbs{font-size:13px;color:var(--flux-muted)}.flux-breadcrumbs a{color:inherit}
+.flux-not-found,.flux-forbidden,.flux-loading{padding:24px;color:var(--flux-muted)}
+.flux-palette-backdrop{position:fixed;inset:0;background:rgba(2,6,23,.45);display:flex;justify-content:center;align-items:flex-start;padding-top:14vh;z-index:9999}
+.flux-palette{width:min(560px,92vw);background:var(--flux-bg);color:var(--flux-fg);border:1px solid var(--flux-border);border-radius:14px;box-shadow:0 24px 60px rgba(0,0,0,.35);overflow:hidden}
+.flux-palette-input{width:100%;box-sizing:border-box;padding:14px 16px;border:0;border-bottom:1px solid var(--flux-border);background:transparent;color:inherit;font-size:15px;outline:none}
+.flux-palette-list{list-style:none;margin:0;padding:6px;max-height:340px;overflow:auto}
+.flux-palette-item{display:flex;justify-content:space-between;align-items:center;gap:12px;padding:9px 12px;border-radius:8px;cursor:pointer;font-size:14px}
+.flux-palette-item.is-active{background:var(--flux-accent);color:var(--flux-accent-fg)}
+.flux-palette-cat{opacity:.65}.flux-palette-empty{padding:14px;color:var(--flux-muted);font-size:14px}
+.flux-palette kbd{font:11px ui-monospace,monospace;padding:2px 6px;border:1px solid currentColor;border-radius:5px;opacity:.7}
+`;
+
+// src/react/http-bridge.ts
+var HttpBridgeError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "HttpBridgeError";
+  }
+  code;
+};
+function createHttpBridge(baseUrl = "") {
+  const listeners2 = /* @__PURE__ */ new Map();
+  let source;
+  const ensureSource = () => {
+    if (source || typeof EventSource === "undefined") return;
+    source = new EventSource(`${baseUrl}/flux/events`);
+    source.onmessage = (ev) => {
+      try {
+        const msg = JSON.parse(ev.data);
+        for (const l of [...listeners2.get(msg.channel) ?? []]) l(msg.payload);
+      } catch {
+      }
+    };
+  };
+  const post = (path, body) => fetch(`${baseUrl}${path}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+  return {
+    async invoke(channel, input, caller) {
+      const res = await (await post("/flux/invoke", { channel, input, caller })).json();
+      if (!res.ok) throw new HttpBridgeError(res.error.message, res.error.code);
+      return res.value;
+    },
+    send(channel, payload, caller) {
+      void post("/flux/send", { channel, payload, caller });
+    },
+    on(channel, listener) {
+      ensureSource();
+      let set = listeners2.get(channel);
+      if (!set) listeners2.set(channel, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => void set.delete(listener);
+    },
+    async bootstrap() {
+      return await (await fetch(`${baseUrl}/flux/bootstrap`)).json();
+    }
+  };
+}
+
+export {
+  RemoteError,
+  PluginsClient,
+  RendererFramework,
+  buildPluginApis,
+  installSharedModules,
+  navigate,
+  useLocation,
+  useNavigate,
+  Link,
+  usePluginRoute,
+  useParams,
+  Breadcrumbs,
+  PluginRoutes,
+  useMenu,
+  PluginProvider,
+  usePluginFramework,
+  PluginErrorBoundary,
+  PluginBoundary,
+  PluginSlot,
+  useExtensionItems,
+  usePlugin,
+  usePlugins,
+  usePluginState,
+  usePluginEvent,
+  usePluginCommand,
+  usePluginService,
+  usePluginIPC,
+  usePluginConfig,
+  StyleHost,
+  useKeybindings,
+  CommandPalette,
+  baseCss,
+  HttpBridgeError,
+  createHttpBridge
+};