@ensera/plugin-frontend 1.0.0

package/dist/index.js

@@ -0,0 +1,2021 @@
+// src/errors.ts
+var PluginFetchError = class extends Error {
+  status;
+  url;
+  requestId;
+  payload;
+  code;
+  constructor(args) {
+    super(args.message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = args.name ?? "PluginFetchError";
+    this.url = args.url;
+    this.requestId = args.requestId;
+    this.status = args.status;
+    this.payload = args.payload;
+    this.code = args.code;
+  }
+};
+var PluginAuthError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginAuthError" });
+  }
+};
+var PluginForbiddenError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginForbiddenError" });
+  }
+};
+var PluginNotFoundError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginNotFoundError" });
+  }
+};
+var PluginValidationError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginValidationError" });
+  }
+};
+var PluginRateLimitError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginRateLimitError" });
+  }
+};
+var PluginServerError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginServerError" });
+  }
+};
+var PluginNetworkError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginNetworkError" });
+  }
+};
+var PluginResponseError = class extends PluginFetchError {
+  constructor(args) {
+    super({ ...args, name: "PluginResponseError" });
+  }
+};
+var PluginStorageError = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "PluginStorageError";
+  }
+};
+var PluginStorageQuotaError = class extends PluginStorageError {
+  constructor(message = "plugin.storage: quota exceeded for this instance") {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "PluginStorageQuotaError";
+  }
+};
+var PluginFetchInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "PluginFetchInputError";
+  }
+};
+
+// src/fetch.ts
+var SDK_VERSION = "0.1.0";
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function genRequestId() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return `req_${Math.random().toString(16).slice(2)}_${Date.now()}`;
+}
+function assertRelativePath(path) {
+  if (!path || typeof path !== "string") {
+    throw new PluginFetchInputError(
+      "plugin.fetch: path must be a non-empty string"
+    );
+  }
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(path) || path.startsWith("//")) {
+    throw new PluginFetchInputError(
+      "plugin.fetch: absolute URLs are not allowed; use a relative path like '/tasks'"
+    );
+  }
+  if (!path.startsWith("/")) {
+    throw new PluginFetchInputError("plugin.fetch: path must start with '/'");
+  }
+  if (path.includes("\\")) {
+    throw new PluginFetchInputError(
+      "plugin.fetch: backslashes are not allowed in paths"
+    );
+  }
+  if (path.includes("/../") || path.endsWith("/..") || path.startsWith("/..")) {
+    throw new PluginFetchInputError(
+      "plugin.fetch: path traversal ('..') is not allowed"
+    );
+  }
+}
+function joinUrl(apiBase, path) {
+  const base = apiBase.replace(/\/+$/, "");
+  return `${base}${path}`;
+}
+function isJsonContentType(ct) {
+  if (!ct) return false;
+  return ct.toLowerCase().includes("application/json");
+}
+async function safeParseJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return void 0;
+  }
+}
+function extractMessageAndCode(payload) {
+  if (!payload || typeof payload !== "object") return {};
+  const p = payload;
+  const message = typeof p.message === "string" ? p.message : void 0;
+  const code = typeof p.code === "string" ? p.code : void 0;
+  return { message, code };
+}
+function makeTypedError(args) {
+  const { status, url, requestId, payload } = args;
+  const { message, code } = extractMessageAndCode(payload);
+  const msg = message ?? `Request failed with status ${status}`;
+  if (status === 401)
+    return new PluginAuthError({
+      message: msg,
+      url,
+      requestId,
+      status,
+      payload,
+      code
+    });
+  if (status === 403)
+    return new PluginForbiddenError({
+      message: msg,
+      url,
+      requestId,
+      status,
+      payload,
+      code
+    });
+  if (status === 404)
+    return new PluginNotFoundError({
+      message: msg,
+      url,
+      requestId,
+      status,
+      payload,
+      code
+    });
+  if (status === 429)
+    return new PluginRateLimitError({
+      message: msg,
+      url,
+      requestId,
+      status,
+      payload,
+      code
+    });
+  if (status === 400 || status === 422) {
+    return new PluginValidationError({
+      message: msg,
+      url,
+      requestId,
+      status,
+      payload,
+      code
+    });
+  }
+  if (status >= 500)
+    return new PluginServerError({
+      message: msg,
+      url,
+      requestId,
+      status,
+      payload,
+      code
+    });
+  return new PluginResponseError({
+    message: msg,
+    url,
+    requestId,
+    status,
+    payload,
+    code
+  });
+}
+function shouldRetry(args) {
+  const { attempt, max, method, status, networkError, allowNonIdempotent } = args;
+  if (attempt >= max) return false;
+  const m = method.toUpperCase();
+  const idempotent = m === "GET" || m === "HEAD" || m === "PUT" || m === "DELETE" || m === "OPTIONS";
+  if (!idempotent && !allowNonIdempotent) return false;
+  if (networkError) return true;
+  if (status === 502 || status === 503 || status === 504) return true;
+  return false;
+}
+async function parseResponse(res, expect) {
+  if (expect === "none") return void 0;
+  if (res.status === 204) return null;
+  if (expect === "blob") return await res.blob();
+  if (expect === "text") return await res.text();
+  const ct = res.headers.get("content-type");
+  if (isJsonContentType(ct)) {
+    return await res.json();
+  }
+  throw new Error("NON_JSON");
+}
+function getLogger(ctx) {
+  const anyCtx = ctx;
+  const logger = anyCtx?.logger;
+  const error = typeof logger?.error === "function" ? logger.error.bind(logger) : console.error.bind(console);
+  const warn = typeof logger?.warn === "function" ? logger.warn.bind(logger) : console.warn.bind(console);
+  const info = typeof logger?.info === "function" ? logger.info.bind(logger) : console.info.bind(console);
+  const debug = typeof logger?.debug === "function" ? logger.debug.bind(logger) : console.debug.bind(console);
+  return { error, warn, info, debug };
+}
+function classifyNetworkFailure(err) {
+  const msg = String(err?.message ?? err ?? "").toLowerCase();
+  if (msg.includes("cors"))
+    return {
+      code: "CORS",
+      hint: "Browser blocked the response due to CORS policy/preflight."
+    };
+  if (msg.includes("mixed content"))
+    return {
+      code: "DNS_OR_TLS",
+      hint: "Mixed content (HTTPS page calling HTTP API) or blocked by browser."
+    };
+  if (msg.includes("ssl") || msg.includes("tls") || msg.includes("certificate")) {
+    return {
+      code: "DNS_OR_TLS",
+      hint: "TLS/SSL handshake or certificate issue."
+    };
+  }
+  if (msg.includes("dns") || msg.includes("name not resolved") || msg.includes("not known")) {
+    return {
+      code: "DNS_OR_TLS",
+      hint: "DNS resolution failure or invalid hostname."
+    };
+  }
+  return {
+    code: "UNREACHABLE",
+    hint: "Server unreachable (network down, CORS, DNS, firewall, or connection issue)."
+  };
+}
+function createPluginFetch(ctx) {
+  const log = getLogger(ctx);
+  return async function pluginFetch(path, options = {}) {
+    assertRelativePath(path);
+    const url = joinUrl(ctx.apiBase, path);
+    const requestId = options.requestId ?? genRequestId();
+    if (options.json !== void 0 && options.body !== void 0) {
+      throw new PluginFetchInputError(
+        "plugin.fetch: provide either 'json' or 'body', not both"
+      );
+    }
+    const method = (options.method ?? "GET").toUpperCase();
+    const expect = options.expect ?? "json";
+    const timeoutMs = options.timeoutMs ?? 3e4;
+    const retryCount = options.retry?.count ?? 0;
+    const backoffMs = options.retry?.backoffMs ?? 250;
+    if (typeof navigator !== "undefined" && navigator && navigator.onLine === false) {
+      const payload = { navigatorOnLine: false };
+      log.error("[plugin.fetch] OFFLINE", { url, requestId, method, payload });
+      throw new PluginNetworkError({
+        message: "Client appears to be offline (navigator.onLine=false)",
+        url,
+        requestId,
+        payload,
+        code: "OFFLINE"
+      });
+    }
+    const headers = new Headers(options.headers ?? {});
+    if (!headers.has("Authorization") && ctx.token) {
+      headers.set("Authorization", `Bearer ${ctx.token}`);
+    }
+    headers.set("X-Ensera-Plugin", ctx.featureSlug);
+    headers.set("X-Ensera-Instance", ctx.instanceId);
+    headers.set("X-Ensera-SDK", SDK_VERSION);
+    headers.set("X-Request-Id", requestId);
+    let body = options.body;
+    if (options.json !== void 0) {
+      body = JSON.stringify(options.json);
+      if (!headers.has("Content-Type"))
+        headers.set("Content-Type", "application/json");
+      if (!headers.has("Accept")) headers.set("Accept", "application/json");
+    } else {
+      if (!headers.has("Accept")) headers.set("Accept", "application/json");
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const callerSignal = options.signal;
+    const onCallerAbort = () => controller.abort();
+    if (callerSignal) {
+      if (callerSignal.aborted) controller.abort();
+      else
+        callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+    }
+    try {
+      let lastStatus;
+      let lastNetworkError = false;
+      for (let attempt = 0; attempt <= retryCount; attempt++) {
+        lastNetworkError = false;
+        try {
+          const res = await fetch(url, {
+            ...options,
+            method,
+            headers,
+            body,
+            signal: controller.signal
+          });
+          lastStatus = res.status;
+          if (!res.ok) {
+            const ct = res.headers.get("content-type");
+            const payload2 = isJsonContentType(ct) ? await safeParseJson(res) : await res.text().catch(() => void 0);
+            const okRetry = shouldRetry({
+              attempt,
+              max: retryCount,
+              method,
+              status: res.status,
+              networkError: false,
+              allowNonIdempotent: false
+              // keep conservative; caller can override by using retry only on GET
+            });
+            if (okRetry) {
+              log.warn("[plugin.fetch] retrying http error", {
+                url,
+                requestId,
+                method,
+                attempt,
+                status: res.status
+              });
+              await sleep(backoffMs * (attempt + 1));
+              continue;
+            }
+            const err = makeTypedError({
+              status: res.status,
+              url,
+              requestId,
+              payload: payload2
+            });
+            log.error("[plugin.fetch] http error", {
+              url,
+              requestId,
+              method,
+              status: res.status,
+              payload: payload2,
+              errorName: err?.name
+            });
+            throw err;
+          }
+          let data;
+          try {
+            data = await parseResponse(res, expect);
+          } catch (e) {
+            if (e?.message === "NON_JSON") {
+              const payloadText = await res.text().catch(() => void 0);
+              const err = new PluginResponseError({
+                message: "Expected JSON response but received non-JSON content",
+                url,
+                requestId,
+                status: res.status,
+                payload: payloadText,
+                code: "NON_JSON_RESPONSE"
+              });
+              log.error("[plugin.fetch] non-json response", {
+                url,
+                requestId,
+                method,
+                status: res.status,
+                payload: payloadText
+              });
+              throw err;
+            }
+            throw e;
+          }
+          log.debug?.("[plugin.fetch] success", {
+            url,
+            requestId,
+            method,
+            status: res.status
+          });
+          return {
+            data,
+            status: res.status,
+            headers: res.headers,
+            url,
+            requestId
+          };
+        } catch (err) {
+          if (controller.signal.aborted) {
+            const code = timedOut ? "TIMEOUT" : "ABORTED";
+            const message = timedOut ? "Request timed out" : "Request aborted";
+            log.error("[plugin.fetch] aborted", {
+              url,
+              requestId,
+              method,
+              attempt,
+              code,
+              timeoutMs,
+              originalError: String(err?.message ?? err)
+            });
+            throw new PluginNetworkError({
+              message,
+              url,
+              requestId,
+              code,
+              payload: {
+                timeoutMs,
+                timedOut,
+                originalError: String(err?.message ?? err)
+              }
+            });
+          }
+          lastNetworkError = true;
+          const okRetry = shouldRetry({
+            attempt,
+            max: retryCount,
+            method,
+            status: lastStatus,
+            networkError: true,
+            allowNonIdempotent: false
+          });
+          if (okRetry) {
+            log.warn("[plugin.fetch] retrying network error", {
+              url,
+              requestId,
+              method,
+              attempt,
+              lastStatus,
+              originalError: String(err?.message ?? err)
+            });
+            await sleep(backoffMs * (attempt + 1));
+            continue;
+          }
+          let detected = {
+            code: "NETWORK_ERROR",
+            hint: "Network error."
+          };
+          if (typeof navigator !== "undefined" && navigator && navigator.onLine === false) {
+            detected = {
+              code: "OFFLINE",
+              hint: "Client appears offline (navigator.onLine=false)."
+            };
+          } else {
+            detected = classifyNetworkFailure(err);
+          }
+          const payload2 = {
+            originalError: String(err?.message ?? err),
+            detectedCode: detected.code,
+            hint: detected.hint,
+            lastStatus
+          };
+          log.error("[plugin.fetch] network error", {
+            url,
+            requestId,
+            method,
+            payload: payload2
+          });
+          throw new PluginNetworkError({
+            message: detected.hint,
+            url,
+            requestId,
+            payload: payload2,
+            code: detected.code
+          });
+        }
+      }
+      const payload = { status: lastStatus, networkError: lastNetworkError };
+      log.error("[plugin.fetch] retry exhausted", {
+        url,
+        requestId,
+        method,
+        payload
+      });
+      throw new PluginNetworkError({
+        message: "Request failed after retries",
+        url,
+        requestId,
+        payload,
+        code: "NETWORK_ERROR"
+      });
+    } finally {
+      clearTimeout(timeout);
+      if (callerSignal)
+        callerSignal.removeEventListener("abort", onCallerAbort);
+    }
+  };
+}
+
+// src/storage.ts
+function assertKey(key) {
+  if (!key || typeof key !== "string") {
+    throw new PluginStorageError(
+      "plugin.storage: key must be a non-empty string"
+    );
+  }
+  if (key.includes(":")) {
+    throw new PluginStorageError("plugin.storage: key must not include ':'");
+  }
+  if (key.length > 200) {
+    throw new PluginStorageError("plugin.storage: key too long");
+  }
+}
+function enc(part) {
+  return encodeURIComponent(part);
+}
+function makeStorageNamespace(ctx, version = 1) {
+  return `ens:v${version}:${enc(ctx.featureSlug)}:${enc(ctx.workspaceId)}:${enc(
+    ctx.spaceId
+  )}:${enc(ctx.instanceId)}:${enc(ctx.userId)}`;
+}
+function createPluginStorage(ctx) {
+  const namespace = makeStorageNamespace(ctx, 1);
+  const prefix = `${namespace}:`;
+  const backend = "localStorage";
+  function fullKey(key) {
+    assertKey(key);
+    return `${prefix}${key}`;
+  }
+  function isOurs(k) {
+    return k.startsWith(prefix);
+  }
+  function estimateBytes(s) {
+    return s.length * 2;
+  }
+  function approxNamespaceBytesUsed() {
+    let bytes = 0;
+    for (let i = 0; i < localStorage.length; i++) {
+      const k = localStorage.key(i);
+      if (!k || !isOurs(k)) continue;
+      const v = localStorage.getItem(k) ?? "";
+      bytes += estimateBytes(k) + estimateBytes(v);
+    }
+    return bytes;
+  }
+  function enforceQuota(nextValue) {
+    const MAX = 1e6;
+    const current = approxNamespaceBytesUsed();
+    const next = current + estimateBytes(nextValue);
+    if (next > MAX) {
+      throw new PluginStorageQuotaError();
+    }
+  }
+  const api = {
+    getItem(key) {
+      const k = fullKey(key);
+      try {
+        return localStorage.getItem(k);
+      } catch (e) {
+        const msg = String(e?.message ?? e);
+        throw new PluginStorageError(`plugin.storage.getItem failed: ${msg}`);
+      }
+    },
+    setItem(key, value) {
+      const k = fullKey(key);
+      if (typeof value !== "string") {
+        throw new PluginStorageError("plugin.storage: value must be a string");
+      }
+      try {
+        enforceQuota(value);
+        localStorage.setItem(k, value);
+      } catch (e) {
+        const msg = String(e?.message ?? e);
+        const name = String(e?.name ?? "");
+        if (name.toLowerCase().includes("quota") || msg.toLowerCase().includes("quota")) {
+          throw new PluginStorageQuotaError(
+            "plugin.storage: browser quota exceeded"
+          );
+        }
+        if (e instanceof PluginStorageQuotaError) throw e;
+        throw new PluginStorageError(`plugin.storage.setItem failed: ${msg}`);
+      }
+    },
+    removeItem(key) {
+      const k = fullKey(key);
+      try {
+        localStorage.removeItem(k);
+      } catch (e) {
+        const msg = String(e?.message ?? e);
+        throw new PluginStorageError(
+          `plugin.storage.removeItem failed: ${msg}`
+        );
+      }
+    },
+    clear() {
+      try {
+        const keysToRemove = [];
+        for (let i = 0; i < localStorage.length; i++) {
+          const k = localStorage.key(i);
+          if (k && isOurs(k)) keysToRemove.push(k);
+        }
+        for (const k of keysToRemove) localStorage.removeItem(k);
+      } catch (e) {
+        const msg = String(e?.message ?? e);
+        throw new PluginStorageError(`plugin.storage.clear failed: ${msg}`);
+      }
+    },
+    keys() {
+      try {
+        const out = [];
+        for (let i = 0; i < localStorage.length; i++) {
+          const k = localStorage.key(i);
+          if (!k || !isOurs(k)) continue;
+          out.push(k.slice(prefix.length));
+        }
+        return out.sort();
+      } catch (e) {
+        const msg = String(e?.message ?? e);
+        throw new PluginStorageError(`plugin.storage.keys failed: ${msg}`);
+      }
+    },
+    getJSON(key) {
+      const raw = api.getItem(key);
+      if (raw == null) return null;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        throw new PluginStorageError(
+          `plugin.storage.getJSON: invalid JSON stored at key '${key}'`
+        );
+      }
+    },
+    setJSON(key, value) {
+      const raw = JSON.stringify(value);
+      api.setItem(key, raw);
+    },
+    info() {
+      let bytes;
+      try {
+        bytes = approxNamespaceBytesUsed();
+      } catch {
+        bytes = void 0;
+      }
+      return { namespace, backend, approxBytesUsed: bytes };
+    }
+  };
+  return api;
+}
+
+// src/log.ts
+function redact(meta) {
+  if (!meta) return meta;
+  const out = {};
+  for (const [k, v] of Object.entries(meta)) {
+    const lk = k.toLowerCase();
+    if (["password", "token", "authorization", "cookie", "secret", "key"].some((x) => lk.includes(x))) {
+      out[k] = "[REDACTED]";
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function createPluginLogger(ctx) {
+  function emit(level, message, meta) {
+    const event = {
+      level,
+      message,
+      meta: redact(meta),
+      tags: {
+        featureSlug: ctx.featureSlug,
+        instanceId: ctx.instanceId,
+        workspaceId: ctx.workspaceId,
+        spaceId: ctx.spaceId,
+        userId: ctx.userId
+      },
+      ts: Date.now()
+    };
+    const fn = level === "debug" ? console.debug : level === "info" ? console.info : level === "warn" ? console.warn : console.error;
+    fn(`[${ctx.featureSlug}] ${message}`, event);
+  }
+  return {
+    debug(message, meta) {
+      emit("debug", message, meta);
+    },
+    info(message, meta) {
+      emit("info", message, meta);
+    },
+    warn(message, meta) {
+      emit("warn", message, meta);
+    },
+    error(message, meta) {
+      emit("error", message, meta);
+    }
+  };
+}
+
+// src/actions.ts
+function defineActions(actions) {
+  return actions;
+}
+var PluginUnknownActionError = class extends Error {
+  actionId;
+  constructor(actionId) {
+    super(`Unknown actionId: ${actionId}`);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "PluginUnknownActionError";
+    this.actionId = actionId;
+  }
+};
+async function runActionSafe(args) {
+  const { actions, actionId, call } = args;
+  if (!actions[actionId]) throw new PluginUnknownActionError(actionId);
+  return await call();
+}
+
+// src/notification/notify.ts
+var NOTIFICATION_TIMEOUT = 5e3;
+function genRequestId2() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return `notif_${Math.random().toString(16).slice(2)}_${Date.now()}`;
+}
+function getCoreOrigin(ctx) {
+  if (ctx.coreOrigin) return ctx.coreOrigin;
+  try {
+    const url = new URL(ctx.apiBase);
+    return url.origin;
+  } catch {
+    return window.location.origin;
+  }
+}
+function createPluginNotify(ctx) {
+  const coreOrigin = getCoreOrigin(ctx);
+  function sendViaPostMessage(notification, options) {
+    return new Promise((resolve, reject) => {
+      const requestId = genRequestId2();
+      let resolved = false;
+      const timeout = setTimeout(() => {
+        if (resolved) return;
+        resolved = true;
+        cleanup();
+        reject(
+          new Error(
+            `Notification request timeout after ${NOTIFICATION_TIMEOUT}ms`
+          )
+        );
+      }, NOTIFICATION_TIMEOUT);
+      const handleMessage = (event) => {
+        if (resolved) return;
+        if (event.origin !== coreOrigin) return;
+        const msg = event.data;
+        if (msg?.type !== "ENSERA_NOTIFICATION_RESPONSE") return;
+        if (msg?.requestId !== requestId) return;
+        resolved = true;
+        cleanup();
+        if (msg.ok) {
+          resolve({
+            success: true,
+            id: msg.id,
+            sent: msg.sent,
+            emailSent: msg.emailSent,
+            pushSent: msg.pushSent
+          });
+        } else {
+          resolve({
+            success: false,
+            error: msg.error
+          });
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timeout);
+        window.removeEventListener("message", handleMessage);
+      };
+      window.addEventListener("message", handleMessage);
+      const request = {
+        type: "ENSERA_SEND_NOTIFICATION",
+        requestId,
+        payload: {
+          ...notification,
+          featureSlug: ctx.featureSlug,
+          options
+        }
+      };
+      window.parent.postMessage(request, coreOrigin);
+    });
+  }
+  async function send(notification, options) {
+    if (!notification.userId?.trim()) {
+      return {
+        success: false,
+        error: "userId is required"
+      };
+    }
+    if (!notification.type?.trim()) {
+      return {
+        success: false,
+        error: "type is required"
+      };
+    }
+    if (!notification.title?.trim()) {
+      return {
+        success: false,
+        error: "title is required"
+      };
+    }
+    if (!notification.message?.trim()) {
+      return {
+        success: false,
+        error: "message is required"
+      };
+    }
+    return sendViaPostMessage(notification, options);
+  }
+  async function sendBulk(notifications, options) {
+    if (!notifications?.length) {
+      return {
+        success: false,
+        count: 0,
+        errors: [
+          { index: 0, userId: "", error: "notifications array is empty" }
+        ]
+      };
+    }
+    const results = await Promise.allSettled(
+      notifications.map((n) => send(n, options))
+    );
+    let count = 0;
+    const errors = [];
+    results.forEach((result, index) => {
+      if (result.status === "fulfilled" && result.value.success) {
+        count++;
+      } else {
+        const error = result.status === "rejected" ? result.reason?.message || "Unknown error" : result.value.error || "Failed to send";
+        errors.push({
+          index,
+          userId: notifications[index]?.userId || "",
+          error
+        });
+      }
+    });
+    return {
+      success: errors.length === 0,
+      count,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
+  async function sendToSelf(notification, options) {
+    return send(
+      {
+        ...notification,
+        userId: ctx.userId
+      },
+      options
+    );
+  }
+  async function requestPermission() {
+    if (!("Notification" in window)) {
+      throw new Error("Browser notifications not supported");
+    }
+    if (Notification.permission === "granted") {
+      return "granted";
+    }
+    if (Notification.permission === "denied") {
+      return "denied";
+    }
+    return await Notification.requestPermission();
+  }
+  return {
+    send,
+    sendBulk,
+    sendToSelf,
+    requestPermission
+  };
+}
+
+// src/runtime.ts
+function createPluginRuntime(ctx) {
+  const fetcher = createPluginFetch(ctx);
+  const fetch2 = (path, options) => fetcher(path, options);
+  return {
+    ctx,
+    fetch: fetch2,
+    get: (path, options = {}) => fetch2(path, { ...options, method: "GET" }),
+    post: (path, options = {}) => fetch2(path, { ...options, method: "POST" }),
+    put: (path, options = {}) => fetch2(path, { ...options, method: "PUT" }),
+    patch: (path, options = {}) => fetch2(path, { ...options, method: "PATCH" }),
+    delete: (path, options = {}) => fetch2(path, { ...options, method: "DELETE" }),
+    storage: createPluginStorage(ctx),
+    log: createPluginLogger(ctx),
+    notify: createPluginNotify(ctx)
+  };
+}
+function attachActionDispatcher(args) {
+  const { actions, runtime } = args;
+  return async ({ requestId, actionId, payload }) => {
+    try {
+      return await runActionSafe({
+        actions,
+        actionId,
+        payload,
+        call: () => actions[actionId]({ actionId, payload, ctx: runtime.ctx, runtime })
+      });
+    } catch (e) {
+      runtime.log.error("Action failed", {
+        requestId,
+        actionId,
+        name: String(e?.name ?? "Error"),
+        message: String(e?.message ?? e),
+        code: e?.code ? String(e.code) : null
+      });
+      if (e instanceof PluginUnknownActionError) throw e;
+      throw e;
+    }
+  };
+}
+
+// src/ui/context-menu-shell.tsx
+import { jsx } from "react/jsx-runtime";
+function ContextMenuShell({ children }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        width: "100%",
+        height: 44,
+        display: "flex",
+        alignItems: "center",
+        gap: 8,
+        padding: "0 10px",
+        boxSizing: "border-box",
+        fontFamily: "ui-sans-serif, system-ui",
+        overflow: "hidden"
+      },
+      children
+    }
+  );
+}
+
+// src/storage_indexeddb.ts
+function assertKey2(key) {
+  if (!key || typeof key !== "string") {
+    throw new PluginStorageError(
+      "plugin.storage: key must be a non-empty string"
+    );
+  }
+  if (key.includes(":")) {
+    throw new PluginStorageError("plugin.storage: key must not include ':'");
+  }
+  if (key.length > 200) {
+    throw new PluginStorageError("plugin.storage: key too long");
+  }
+}
+function normalizeQuotaError(e) {
+  const msg = String(e?.message ?? e);
+  const name = String(e?.name ?? "");
+  return name.toLowerCase().includes("quota") || msg.toLowerCase().includes("quota") || msg.toLowerCase().includes("exceeded") || msg.toLowerCase().includes("storage");
+}
+function openDb(dbName, storeName) {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(dbName, 1);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function withStore(db, storeName, mode, fn) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(storeName, mode);
+    const store = tx.objectStore(storeName);
+    const req = fn(store);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+  });
+}
+function createPluginStorageIndexedDB(ctx) {
+  const namespace = makeStorageNamespace(ctx, 1);
+  const prefix = `${namespace}:`;
+  const backend = "indexedDB";
+  const DB_NAME = "ens-plugin-storage";
+  const STORE_NAME = "kv";
+  let dbPromise = null;
+  const getDb = () => dbPromise ??= openDb(DB_NAME, STORE_NAME);
+  function fullKey(key) {
+    assertKey2(key);
+    return `${prefix}${key}`;
+  }
+  function isOurs(k) {
+    return k.startsWith(prefix);
+  }
+  let opQueue = Promise.resolve();
+  function enqueue(op) {
+    const run = opQueue.then(op, op);
+    opQueue = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  const api = {
+    async getItem(key) {
+      const k = fullKey(key);
+      try {
+        const db = await getDb();
+        const val = await withStore(
+          db,
+          STORE_NAME,
+          "readonly",
+          (s) => s.get(k)
+        );
+        return val ?? null;
+      } catch (e) {
+        const msg = String(e?.message ?? e);
+        throw new PluginStorageError(`plugin.storage.getItem failed: ${msg}`);
+      }
+    },
+    async setItem(key, value) {
+      const k = fullKey(key);
+      if (typeof value !== "string") {
+        throw new PluginStorageError("plugin.storage: value must be a string");
+      }
+      return enqueue(async () => {
+        try {
+          const db = await getDb();
+          await withStore(db, STORE_NAME, "readwrite", (s) => s.put(value, k));
+        } catch (e) {
+          if (normalizeQuotaError(e)) {
+            throw new PluginStorageQuotaError(
+              "plugin.storage: browser quota exceeded"
+            );
+          }
+          const msg = String(e?.message ?? e);
+          throw new PluginStorageError(`plugin.storage.setItem failed: ${msg}`);
+        }
+      });
+    },
+    async removeItem(key) {
+      const k = fullKey(key);
+      return enqueue(async () => {
+        try {
+          const db = await getDb();
+          await withStore(db, STORE_NAME, "readwrite", (s) => s.delete(k));
+        } catch (e) {
+          const msg = String(e?.message ?? e);
+          throw new PluginStorageError(
+            `plugin.storage.removeItem failed: ${msg}`
+          );
+        }
+      });
+    },
+    async clear() {
+      return enqueue(async () => {
+        try {
+          const db = await getDb();
+          const keys = await this.keys();
+          const tx = db.transaction(STORE_NAME, "readwrite");
+          const store = tx.objectStore(STORE_NAME);
+          for (const key of keys) {
+            store.delete(fullKey(key));
+          }
+          await new Promise((resolve, reject) => {
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+            tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+          });
+        } catch (e) {
+          const msg = String(e?.message ?? e);
+          throw new PluginStorageError(`plugin.storage.clear failed: ${msg}`);
+        }
+      });
+    },
+    async keys() {
+      try {
+        const db = await getDb();
+        const allKeys = await withStore(
+          db,
+          STORE_NAME,
+          "readonly",
+          (s) => s.getAllKeys ? s.getAllKeys() : s.getAllKeys()
+        );
+        const out = [];
+        for (const k of allKeys) {
+          if (typeof k !== "string") continue;
+          if (!isOurs(k)) continue;
+          out.push(k.slice(prefix.length));
+        }
+        return out.sort();
+      } catch (e) {
+        const msg = String(e?.message ?? e);
+        throw new PluginStorageError(`plugin.storage.keys failed: ${msg}`);
+      }
+    },
+    async getJSON(key) {
+      const raw = await this.getItem(key);
+      if (raw == null) return null;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        throw new PluginStorageError(
+          `plugin.storage.getJSON: invalid JSON stored at key '${key}'`
+        );
+      }
+    },
+    async setJSON(key, value) {
+      const raw = JSON.stringify(value);
+      await this.setItem(key, raw);
+    },
+    async info() {
+      return { namespace, backend };
+    }
+  };
+  return api;
+}
+
+// src/broadcast.ts
+import { useEffect, useRef } from "react";
+var _instanceId;
+var _coreOrigin;
+function initBroadcast(opts) {
+  _instanceId = opts.instanceId;
+  _coreOrigin = opts.coreOrigin || "*";
+}
+function broadcast(event, payload = {}) {
+  if (typeof window === "undefined") return;
+  if (window.parent === window) return;
+  const message = {
+    type: "ENSERA_SYNC_BROADCAST",
+    event,
+    payload,
+    sourceInstanceId: _instanceId
+  };
+  try {
+    window.parent.postMessage(message, _coreOrigin || "*");
+  } catch (err) {
+    console.debug("[plugin-frontend] broadcast postMessage failed:", err);
+  }
+}
+function useBroadcastListener(event, callback) {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  const events = Array.isArray(event) ? event : [event];
+  useEffect(() => {
+    function handleMessage(msg) {
+      const data = msg.data;
+      if (!data || data.type !== "ENSERA_SYNC_RELAY") return;
+      if (data.sourceInstanceId && data.sourceInstanceId === _instanceId)
+        return;
+      if (!events.includes(data.event)) return;
+      callbackRef.current(data.payload ?? {});
+    }
+    window.addEventListener("message", handleMessage);
+    return () => window.removeEventListener("message", handleMessage);
+  }, [events.join(",")]);
+}
+function onBroadcast(event, callback) {
+  const events = Array.isArray(event) ? event : [event];
+  function handleMessage(msg) {
+    const data = msg.data;
+    if (!data || data.type !== "ENSERA_SYNC_RELAY") return;
+    if (data.sourceInstanceId && data.sourceInstanceId === _instanceId) return;
+    if (!events.includes(data.event)) return;
+    callback(data.payload ?? {});
+  }
+  window.addEventListener("message", handleMessage);
+  return () => window.removeEventListener("message", handleMessage);
+}
+
+// src/sync.ts
+function createSyncedState(args) {
+  const { featureSlug, instanceId, initialState, onSync } = args;
+  let currentState = initialState;
+  const channelName = `ensera:sync:${featureSlug}`;
+  let channel = null;
+  const clientId = Math.random().toString(36).substring(2, 10);
+  const handleMessage = (msg) => {
+    if (msg.clientId === clientId) return;
+    if (msg.type !== "STATE_SYNC") return;
+    if (msg.featureSlug !== featureSlug) return;
+    currentState = msg.state;
+    if (onSync) {
+      onSync(msg.state, msg.instanceId);
+    }
+  };
+  if (typeof BroadcastChannel !== "undefined") {
+    try {
+      channel = new BroadcastChannel(channelName);
+      channel.onmessage = (event) => {
+        handleMessage(event.data);
+      };
+    } catch (e) {
+      console.warn("BroadcastChannel not available:", e);
+    }
+  }
+  function setState(newState) {
+    const updatedState = typeof newState === "function" ? newState(currentState) : newState;
+    currentState = updatedState;
+    const msg = {
+      type: "STATE_SYNC",
+      featureSlug,
+      instanceId,
+      clientId,
+      state: updatedState,
+      timestamp: Date.now()
+    };
+    if (channel) {
+      try {
+        channel.postMessage(msg);
+      } catch (e) {
+        console.error("Failed to broadcast state:", e);
+      }
+    }
+    return updatedState;
+  }
+  function getState() {
+    return currentState;
+  }
+  function cleanup() {
+    if (channel) {
+      try {
+        channel.close();
+      } catch {
+      }
+      channel = null;
+    }
+  }
+  return {
+    setState,
+    getState,
+    cleanup
+  };
+}
+function useSyncedState(args) {
+  const { featureSlug, instanceId, initialState } = args;
+  const sync = createSyncedState({
+    featureSlug,
+    instanceId,
+    initialState
+  });
+  return [sync.getState(), sync.setState];
+}
+
+// src/ui/tokens.ts
+var tokens = {
+  // Spacing scale (in pixels)
+  spacing: {
+    xs: 4,
+    sm: 8,
+    md: 12,
+    lg: 16,
+    xl: 20,
+    xxl: 24
+  },
+  // Row heights for context menu items
+  rowHeight: {
+    compact: 32,
+    default: 44,
+    comfortable: 56,
+    large: 72
+  },
+  // Font sizes
+  fontSize: {
+    xs: 11,
+    sm: 12,
+    md: 14,
+    lg: 16,
+    xl: 18
+  },
+  // Font weights
+  fontWeight: {
+    normal: 400,
+    medium: 500,
+    semibold: 600,
+    bold: 700
+  },
+  // Border radius
+  radius: {
+    sm: 4,
+    md: 6,
+    lg: 8,
+    xl: 12,
+    full: 9999
+  },
+  // Colors (Light mode - context menu specific)
+  colors: {
+    // Backgrounds
+    bg: {
+      primary: "#FFFFFF",
+      secondary: "#F9FAFB",
+      hover: "#F3F4F6",
+      active: "#E5E7EB",
+      disabled: "#F9FAFB"
+    },
+    // Borders
+    border: {
+      default: "#E5E7EB",
+      hover: "#D1D5DB",
+      focus: "#3B82F6"
+    },
+    // Text
+    text: {
+      primary: "#111827",
+      secondary: "#6B7280",
+      tertiary: "#9CA3AF",
+      disabled: "#D1D5DB",
+      inverse: "#FFFFFF"
+    },
+    // Status/Accent
+    accent: {
+      primary: "#3B82F6",
+      primaryHover: "#2563EB",
+      success: "#10B981",
+      warning: "#F59E0B",
+      danger: "#EF4444"
+    }
+  },
+  // Shadows
+  shadow: {
+    sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+    md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)",
+    lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05)",
+    xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04)"
+  },
+  // Transitions
+  transition: {
+    fast: "150ms cubic-bezier(0.4, 0, 0.2, 1)",
+    base: "200ms cubic-bezier(0.4, 0, 0.2, 1)",
+    slow: "300ms cubic-bezier(0.4, 0, 0.2, 1)"
+  }
+};
+
+// src/ui/Button.tsx
+import React from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var getVariantStyles = (variant) => {
+  const baseStyles = {
+    border: "1px solid",
+    cursor: "pointer",
+    fontWeight: tokens.fontWeight.medium,
+    transition: `all ${tokens.transition.fast}`,
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    gap: tokens.spacing.sm,
+    fontFamily: "ui-sans-serif, system-ui",
+    outline: "none"
+  };
+  switch (variant) {
+    case "primary":
+      return {
+        ...baseStyles,
+        backgroundColor: tokens.colors.accent.primary,
+        borderColor: tokens.colors.accent.primary,
+        color: tokens.colors.text.inverse
+      };
+    case "secondary":
+      return {
+        ...baseStyles,
+        backgroundColor: tokens.colors.bg.primary,
+        borderColor: tokens.colors.border.default,
+        color: tokens.colors.text.primary
+      };
+    case "ghost":
+      return {
+        ...baseStyles,
+        backgroundColor: "transparent",
+        borderColor: "transparent",
+        color: tokens.colors.text.secondary
+      };
+    case "danger":
+      return {
+        ...baseStyles,
+        backgroundColor: tokens.colors.accent.danger,
+        borderColor: tokens.colors.accent.danger,
+        color: tokens.colors.text.inverse
+      };
+    default:
+      return baseStyles;
+  }
+};
+var getHoverStyles = (variant) => {
+  switch (variant) {
+    case "primary":
+      return {
+        backgroundColor: tokens.colors.accent.primaryHover,
+        borderColor: tokens.colors.accent.primaryHover
+      };
+    case "secondary":
+      return {
+        backgroundColor: tokens.colors.bg.hover,
+        borderColor: tokens.colors.border.hover
+      };
+    case "ghost":
+      return {
+        backgroundColor: tokens.colors.bg.hover
+      };
+    case "danger":
+      return {
+        backgroundColor: "#DC2626"
+      };
+    default:
+      return {};
+  }
+};
+var getSizeStyles = (size) => {
+  switch (size) {
+    case "sm":
+      return {
+        height: 28,
+        padding: `0 ${tokens.spacing.md}px`,
+        fontSize: tokens.fontSize.sm,
+        borderRadius: tokens.radius.md
+      };
+    case "md":
+      return {
+        height: 36,
+        padding: `0 ${tokens.spacing.lg}px`,
+        fontSize: tokens.fontSize.md,
+        borderRadius: tokens.radius.lg
+      };
+    case "lg":
+      return {
+        height: 44,
+        padding: `0 ${tokens.spacing.xl}px`,
+        fontSize: tokens.fontSize.lg,
+        borderRadius: tokens.radius.lg
+      };
+    default:
+      return {};
+  }
+};
+var Button = React.forwardRef(
+  ({
+    variant = "secondary",
+    size = "md",
+    fullWidth = false,
+    icon,
+    iconPosition = "left",
+    disabled,
+    children,
+    style,
+    onMouseEnter,
+    onMouseLeave,
+    ...props
+  }, ref) => {
+    const [isHovered, setIsHovered] = React.useState(false);
+    const baseStyles = getVariantStyles(variant);
+    const sizeStyles = getSizeStyles(size);
+    const hoverStyles = isHovered ? getHoverStyles(variant) : {};
+    const disabledStyles = disabled ? {
+      opacity: 0.5,
+      cursor: "not-allowed",
+      pointerEvents: "none"
+    } : {};
+    const widthStyle = fullWidth ? { width: "100%" } : {};
+    const combinedStyles = {
+      ...baseStyles,
+      ...sizeStyles,
+      ...hoverStyles,
+      ...disabledStyles,
+      ...widthStyle,
+      ...style
+    };
+    return /* @__PURE__ */ jsxs(
+      "button",
+      {
+        ref,
+        disabled,
+        style: combinedStyles,
+        onMouseEnter: (e) => {
+          setIsHovered(true);
+          onMouseEnter?.(e);
+        },
+        onMouseLeave: (e) => {
+          setIsHovered(false);
+          onMouseLeave?.(e);
+        },
+        ...props,
+        children: [
+          icon && iconPosition === "left" && /* @__PURE__ */ jsx2("span", { children: icon }),
+          children,
+          icon && iconPosition === "right" && /* @__PURE__ */ jsx2("span", { children: icon })
+        ]
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+
+// src/ui/Input.tsx
+import React2 from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var getSizeStyles2 = (size) => {
+  switch (size) {
+    case "sm":
+      return {
+        height: 28,
+        padding: `0 ${tokens.spacing.sm}px`,
+        fontSize: tokens.fontSize.sm
+      };
+    case "md":
+      return {
+        height: 36,
+        padding: `0 ${tokens.spacing.md}px`,
+        fontSize: tokens.fontSize.md
+      };
+    case "lg":
+      return {
+        height: 44,
+        padding: `0 ${tokens.spacing.lg}px`,
+        fontSize: tokens.fontSize.lg
+      };
+    default:
+      return {};
+  }
+};
+var Input = React2.forwardRef(
+  ({
+    size = "md",
+    variant = "default",
+    error = false,
+    fullWidth = false,
+    disabled = false,
+    leftIcon,
+    rightIcon,
+    style,
+    className,
+    ...props
+  }, ref) => {
+    const [isFocused, setIsFocused] = React2.useState(false);
+    const sizeStyles = getSizeStyles2(size);
+    const baseStyles = {
+      border: "1px solid",
+      borderRadius: tokens.radius.lg,
+      fontFamily: "ui-sans-serif, system-ui",
+      transition: `all ${tokens.transition.fast}`,
+      outline: "none",
+      ...sizeStyles
+    };
+    const variantStyles = variant === "filled" ? {
+      backgroundColor: tokens.colors.bg.secondary,
+      borderColor: "transparent"
+    } : {
+      backgroundColor: tokens.colors.bg.primary,
+      borderColor: tokens.colors.border.default
+    };
+    const stateStyles = error ? {
+      borderColor: tokens.colors.accent.danger
+    } : isFocused ? {
+      borderColor: tokens.colors.border.focus,
+      boxShadow: `0 0 0 3px rgba(59, 130, 246, 0.1)`
+    } : {};
+    const disabledStyles = disabled ? {
+      backgroundColor: tokens.colors.bg.disabled,
+      color: tokens.colors.text.disabled,
+      cursor: "not-allowed"
+    } : {};
+    const widthStyle = fullWidth ? { width: "100%" } : {};
+    const iconPaddingStyles = {};
+    if (leftIcon) {
+      iconPaddingStyles.paddingLeft = `${tokens.spacing.xl + 4}px`;
+    }
+    if (rightIcon) {
+      iconPaddingStyles.paddingRight = `${tokens.spacing.xl + 4}px`;
+    }
+    const combinedStyles = {
+      ...baseStyles,
+      ...variantStyles,
+      ...stateStyles,
+      ...disabledStyles,
+      ...widthStyle,
+      ...iconPaddingStyles,
+      ...style
+    };
+    if (leftIcon || rightIcon) {
+      return /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          style: {
+            position: "relative",
+            display: "inline-flex",
+            alignItems: "center",
+            width: fullWidth ? "100%" : "auto"
+          },
+          children: [
+            leftIcon && /* @__PURE__ */ jsx3(
+              "div",
+              {
+                style: {
+                  position: "absolute",
+                  left: tokens.spacing.md,
+                  display: "flex",
+                  alignItems: "center",
+                  color: tokens.colors.text.tertiary,
+                  pointerEvents: "none"
+                },
+                children: leftIcon
+              }
+            ),
+            /* @__PURE__ */ jsx3(
+              "input",
+              {
+                ref,
+                disabled,
+                style: combinedStyles,
+                className,
+                onFocus: (e) => {
+                  setIsFocused(true);
+                  props.onFocus?.(e);
+                },
+                onBlur: (e) => {
+                  setIsFocused(false);
+                  props.onBlur?.(e);
+                },
+                ...props
+              }
+            ),
+            rightIcon && /* @__PURE__ */ jsx3(
+              "div",
+              {
+                style: {
+                  position: "absolute",
+                  right: tokens.spacing.md,
+                  display: "flex",
+                  alignItems: "center",
+                  color: tokens.colors.text.tertiary,
+                  pointerEvents: "none"
+                },
+                children: rightIcon
+              }
+            )
+          ]
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx3(
+      "input",
+      {
+        ref,
+        disabled,
+        style: combinedStyles,
+        className,
+        onFocus: (e) => {
+          setIsFocused(true);
+          props.onFocus?.(e);
+        },
+        onBlur: (e) => {
+          setIsFocused(false);
+          props.onBlur?.(e);
+        },
+        ...props
+      }
+    );
+  }
+);
+Input.displayName = "Input";
+
+// src/ui/IconButton.tsx
+import React3 from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var getSizeStyles3 = (size) => {
+  switch (size) {
+    case "sm":
+      return {
+        width: 28,
+        height: 28,
+        fontSize: 14
+      };
+    case "md":
+      return {
+        width: 36,
+        height: 36,
+        fontSize: 18
+      };
+    case "lg":
+      return {
+        width: 44,
+        height: 44,
+        fontSize: 20
+      };
+    default:
+      return {};
+  }
+};
+var getVariantStyles2 = (variant) => {
+  const baseStyles = {
+    border: "1px solid",
+    cursor: "pointer",
+    transition: `all ${tokens.transition.fast}`,
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    outline: "none"
+  };
+  switch (variant) {
+    case "default":
+      return {
+        ...baseStyles,
+        backgroundColor: tokens.colors.bg.primary,
+        borderColor: tokens.colors.border.default,
+        color: tokens.colors.text.primary
+      };
+    case "ghost":
+      return {
+        ...baseStyles,
+        backgroundColor: "transparent",
+        borderColor: "transparent",
+        color: tokens.colors.text.secondary
+      };
+    case "primary":
+      return {
+        ...baseStyles,
+        backgroundColor: tokens.colors.accent.primary,
+        borderColor: tokens.colors.accent.primary,
+        color: tokens.colors.text.inverse
+      };
+    case "danger":
+      return {
+        ...baseStyles,
+        backgroundColor: "transparent",
+        borderColor: "transparent",
+        color: tokens.colors.accent.danger
+      };
+    default:
+      return baseStyles;
+  }
+};
+var getHoverStyles2 = (variant) => {
+  switch (variant) {
+    case "default":
+      return {
+        backgroundColor: tokens.colors.bg.hover,
+        borderColor: tokens.colors.border.hover
+      };
+    case "ghost":
+      return {
+        backgroundColor: tokens.colors.bg.hover
+      };
+    case "primary":
+      return {
+        backgroundColor: tokens.colors.accent.primaryHover,
+        borderColor: tokens.colors.accent.primaryHover
+      };
+    case "danger":
+      return {
+        backgroundColor: "rgba(239, 68, 68, 0.1)"
+      };
+    default:
+      return {};
+  }
+};
+var IconButton = React3.forwardRef(
+  ({
+    size = "md",
+    variant = "ghost",
+    icon,
+    disabled,
+    style,
+    onMouseEnter,
+    onMouseLeave,
+    ...props
+  }, ref) => {
+    const [isHovered, setIsHovered] = React3.useState(false);
+    const baseStyles = getVariantStyles2(variant);
+    const sizeStyles = getSizeStyles3(size);
+    const hoverStyles = isHovered ? getHoverStyles2(variant) : {};
+    const disabledStyles = disabled ? {
+      opacity: 0.5,
+      cursor: "not-allowed",
+      pointerEvents: "none"
+    } : {};
+    const combinedStyles = {
+      ...baseStyles,
+      ...sizeStyles,
+      ...hoverStyles,
+      ...disabledStyles,
+      borderRadius: tokens.radius.lg,
+      ...style
+    };
+    return /* @__PURE__ */ jsx4(
+      "button",
+      {
+        ref,
+        disabled,
+        style: combinedStyles,
+        onMouseEnter: (e) => {
+          setIsHovered(true);
+          onMouseEnter?.(e);
+        },
+        onMouseLeave: (e) => {
+          setIsHovered(false);
+          onMouseLeave?.(e);
+        },
+        ...props,
+        children: icon
+      }
+    );
+  }
+);
+IconButton.displayName = "IconButton";
+
+// src/ui/Row.tsx
+import React4 from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var getAlignItems = (align) => {
+  switch (align) {
+    case "start":
+      return "flex-start";
+    case "center":
+      return "center";
+    case "end":
+      return "flex-end";
+    case "stretch":
+      return "stretch";
+    default:
+      return "center";
+  }
+};
+var getJustifyContent = (justify) => {
+  switch (justify) {
+    case "start":
+      return "flex-start";
+    case "center":
+      return "center";
+    case "end":
+      return "flex-end";
+    case "between":
+      return "space-between";
+    case "around":
+      return "space-around";
+    case "evenly":
+      return "space-evenly";
+    default:
+      return "flex-start";
+  }
+};
+var Row = React4.forwardRef(
+  ({
+    height = "default",
+    customHeight,
+    align = "center",
+    justify = "start",
+    gap = tokens.spacing.md,
+    padding = tokens.spacing.md,
+    fullWidth = true,
+    divider = false,
+    children,
+    style,
+    ...props
+  }, ref) => {
+    const rowHeight = customHeight ?? tokens.rowHeight[height];
+    const containerStyles = {
+      display: "flex",
+      alignItems: getAlignItems(align),
+      justifyContent: getJustifyContent(justify),
+      gap,
+      padding: `0 ${padding}px`,
+      height: typeof rowHeight === "number" ? `${rowHeight}px` : rowHeight,
+      width: fullWidth ? "100%" : "auto",
+      boxSizing: "border-box",
+      fontFamily: "ui-sans-serif, system-ui",
+      overflow: "hidden",
+      ...style
+    };
+    if (divider && React4.Children.count(children) > 1) {
+      const childrenArray = React4.Children.toArray(children);
+      const childrenWithDividers = [];
+      childrenArray.forEach((child, index) => {
+        childrenWithDividers.push(
+          /* @__PURE__ */ jsx5(React4.Fragment, { children: child }, `child-${index}`)
+        );
+        if (index < childrenArray.length - 1) {
+          childrenWithDividers.push(
+            /* @__PURE__ */ jsx5(
+              "div",
+              {
+                style: {
+                  width: 1,
+                  height: "60%",
+                  backgroundColor: tokens.colors.border.default,
+                  flexShrink: 0
+                }
+              },
+              `divider-${index}`
+            )
+          );
+        }
+      });
+      return /* @__PURE__ */ jsx5("div", { ref, style: containerStyles, ...props, children: childrenWithDividers });
+    }
+    return /* @__PURE__ */ jsx5("div", { ref, style: containerStyles, ...props, children });
+  }
+);
+Row.displayName = "Row";
+var ContextRow = React4.forwardRef(
+  ({
+    expandable = false,
+    minHeight = tokens.rowHeight.default,
+    maxHeight = 120,
+    children,
+    style,
+    ...props
+  }, ref) => {
+    const heightStyles = expandable ? {
+      minHeight: `${minHeight}px`,
+      maxHeight: `${maxHeight}px`,
+      height: "auto"
+    } : {
+      height: `${minHeight}px`
+    };
+    return /* @__PURE__ */ jsx5(
+      Row,
+      {
+        ref,
+        customHeight: "auto",
+        style: {
+          ...heightStyles,
+          ...style
+        },
+        ...props,
+        children
+      }
+    );
+  }
+);
+ContextRow.displayName = "ContextRow";
+
+// src/overlay.ts
+function openOverlay(featureSlug) {
+  const msg = {
+    type: "ENSERA_OPEN_OVERLAY",
+    featureSlug
+  };
+  window.parent.postMessage(msg, "*");
+}
+
+// src/context.ts
+function setupContextMenuRelay(ctx) {
+  if (typeof window === "undefined") return () => {
+  };
+  if (window === window.parent) return () => {
+  };
+  const onContextMenu = (e) => {
+    if (e.defaultPrevented) return;
+    const target = e.target;
+    if (target?.closest("[data-no-context]")) return;
+    e.preventDefault();
+    window.parent.postMessage(
+      {
+        type: "OPEN_CONTEXT_MENU",
+        x: e.clientX,
+        y: e.clientY,
+        fromIframe: true,
+        instanceId: ctx.instanceId
+      },
+      "*"
+    );
+  };
+  document.addEventListener("contextmenu", onContextMenu);
+  return () => document.removeEventListener("contextmenu", onContextMenu);
+}
+export {
+  Button,
+  ContextMenuShell,
+  ContextRow,
+  IconButton,
+  Input,
+  PluginAuthError,
+  PluginFetchError,
+  PluginFetchInputError,
+  PluginForbiddenError,
+  PluginNetworkError,
+  PluginNotFoundError,
+  PluginRateLimitError,
+  PluginResponseError,
+  PluginServerError,
+  PluginStorageError,
+  PluginStorageQuotaError,
+  PluginUnknownActionError,
+  PluginValidationError,
+  Row,
+  attachActionDispatcher,
+  broadcast,
+  createPluginFetch,
+  createPluginLogger,
+  createPluginNotify,
+  createPluginRuntime,
+  createPluginStorage,
+  createPluginStorageIndexedDB,
+  createSyncedState,
+  defineActions,
+  initBroadcast,
+  makeStorageNamespace,
+  onBroadcast,
+  openOverlay,
+  runActionSafe,
+  setupContextMenuRelay,
+  tokens,
+  useBroadcastListener,
+  useSyncedState
+};