@ops-ai/electron-feature-flags-toggly 1.0.0

package/dist/main/index.js

@@ -0,0 +1,830 @@
+import { toBooleanDefinitions, appendEvaluationContext, resolveEvaluatedDefinition, normalizeEntityContext, evaluateEvaluatedGate } from '@ops-ai/toggly-hooks-types';
+import { InMemoryJwksCache, readResponseBody, parseEvaluatedResponseBody, unwrapDefsPayload } from '@ops-ai/toggly-signed-defs';
+import { applyLocalGate, buildFlagGateIndex } from '@ops-ai/toggly-local-gates';
+import WebSocket from 'ws';
+import { randomUUID } from 'crypto';
+import { readFile, mkdir, writeFile, unlink } from 'fs/promises';
+import { join } from 'path';
+
+// src/main/client.ts
+function sanitizeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function buildCacheFilePath(userDataPath, appKey, environment, contextKey) {
+  const dir = join(userDataPath, "toggly");
+  const name = `flags-${sanitizeSegment(appKey)}-${sanitizeSegment(environment)}-${sanitizeSegment(contextKey)}.json`;
+  return join(dir, name);
+}
+var DiskFeatureCache = class {
+  constructor(userDataPath) {
+    this.userDataPath = userDataPath;
+  }
+  userDataPath;
+  filePath(appKey, environment, contextKey) {
+    return buildCacheFilePath(this.userDataPath, appKey, environment, contextKey);
+  }
+  async read(appKey, environment, contextKey) {
+    const path = this.filePath(appKey, environment, contextKey);
+    try {
+      const raw = await readFile(path, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || !parsed.flags || typeof parsed.flags !== "object") {
+        return null;
+      }
+      return {
+        flags: parsed.flags,
+        revision: parsed.revision ?? null,
+        updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async write(appKey, environment, contextKey, entry) {
+    const path = this.filePath(appKey, environment, contextKey);
+    await mkdir(join(this.userDataPath, "toggly"), { recursive: true });
+    await writeFile(path, JSON.stringify(entry), "utf-8");
+  }
+  async clear(appKey, environment, contextKey) {
+    const path = this.filePath(appKey, environment, contextKey);
+    try {
+      await unlink(path);
+    } catch {
+    }
+  }
+};
+
+// src/sdk-identity.ts
+var SDK_ID = "electron";
+var SDK_VERSION = "1.0.0";
+var SDK_HEADER_ID = "X-Toggly-Sdk";
+var SDK_HEADER_VERSION = "X-Toggly-Sdk-Version";
+function sdkUserAgent() {
+  return `toggly-${SDK_ID}/${SDK_VERSION}`;
+}
+function sdkCustomHeaders() {
+  return {
+    [SDK_HEADER_ID]: SDK_ID,
+    [SDK_HEADER_VERSION]: SDK_VERSION
+  };
+}
+function appendSdkQueryParams(params) {
+  params.set("sdk", SDK_ID);
+  params.set("sdkVersion", SDK_VERSION);
+}
+function buildDefinitionFetchHeaders(existing = {}) {
+  return {
+    ...existing,
+    "User-Agent": sdkUserAgent(),
+    ...sdkCustomHeaders()
+  };
+}
+
+// src/ws-sync.ts
+var DEFINITIONS_REVISION_HEADER = "X-Definitions-Revision";
+var WS_RECONNECT_BASE_MS = 5e3;
+var WS_RECONNECT_MAX_MS = 6e4;
+var REFRESH_DEBOUNCE_MS = 300;
+function buildWebSocketUrl(baseUri, appKey, cachedEtag) {
+  const wsBase = baseUri.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://").replace(/\/$/, "");
+  const params = new URLSearchParams();
+  if (cachedEtag) {
+    params.set("rev", cachedEtag);
+  }
+  appendSdkQueryParams(params);
+  const query = params.toString();
+  return `${wsBase}/${appKey}/ws${query ? `?${query}` : ""}`;
+}
+function getNextReconnectDelayMs(attempt) {
+  return Math.min(WS_RECONNECT_BASE_MS * Math.pow(2, attempt), WS_RECONNECT_MAX_MS);
+}
+function shouldFetchOnSync(message, cachedEtag) {
+  if (message.type !== "sync") {
+    return false;
+  }
+  if (message.unchanged === true) {
+    return false;
+  }
+  if (!cachedEtag) {
+    return true;
+  }
+  if (message.etag && message.etag !== cachedEtag) {
+    return true;
+  }
+  return false;
+}
+function shouldFetchOnFlagsUpdated(message, cachedEtag) {
+  if (message.type !== "flags-updated" && message.type !== "update") {
+    return false;
+  }
+  if (!message.etag || !cachedEtag) {
+    return true;
+  }
+  return message.etag !== cachedEtag;
+}
+function shouldFetchOnSigningKeyUpdated(message) {
+  return message.type === "signing-key-updated";
+}
+function planFlagsUpdatedRefresh(message, previousRevision) {
+  if (shouldFetchOnSigningKeyUpdated(message)) {
+    return { action: "refresh-jwks" };
+  }
+  if (shouldFetchOnFlagsUpdated(message, previousRevision)) {
+    return { action: "refresh-pinned", pin: message.etag ?? null };
+  }
+  return { action: "none" };
+}
+function applyFlagsUpdatedPlan(plan, message, hooks) {
+  if (plan.action === "refresh-jwks") {
+    hooks.refreshJwks();
+    return;
+  }
+  if (plan.action === "refresh-pinned") {
+    hooks.refreshPinned(plan.pin);
+    return;
+  }
+  if (message.etag) {
+    hooks.cacheEtagIfPresent(message.etag);
+  }
+}
+function extractDefinitionsRevision(response) {
+  if (!response.headers?.get) {
+    return null;
+  }
+  return response.headers.get(DEFINITIONS_REVISION_HEADER) ?? response.headers.get("ETag");
+}
+function appendDefinitionsRevisionParam(url, rev) {
+  if (!rev) {
+    return url;
+  }
+  try {
+    const parsed = new URL(url);
+    parsed.searchParams.set("rev", rev);
+    return parsed.toString();
+  } catch {
+    const separator = url.includes("?") ? "&" : "?";
+    return `${url}${separator}rev=${encodeURIComponent(rev)}`;
+  }
+}
+
+// src/main/client.ts
+var DEFAULT_BASE_URI = "https://definitions.toggly.io";
+var DEFAULT_ENVIRONMENT = "Production";
+var DEFAULT_CONNECT_TIMEOUT = 5e3;
+var DEFAULT_REFRESH_INTERVAL = 3 * 60 * 1e3;
+var FALLBACK_REFRESH_INTERVAL = 20 * 60 * 1e3;
+var HookExecutor = class {
+  hooks = [];
+  addHook(hook) {
+    this.hooks.push(hook);
+  }
+  async executeBeforeEvaluation(flagKey, defaultValue) {
+    let data = void 0;
+    for (const hook of this.hooks) {
+      if (hook.beforeEvaluation) {
+        data = await hook.beforeEvaluation(flagKey, defaultValue) ?? data;
+      }
+    }
+    return data;
+  }
+  async executeAfterEvaluation(flagKey, data, result) {
+    for (const hook of this.hooks) {
+      if (hook.afterEvaluation) {
+        await hook.afterEvaluation(flagKey, data, result);
+      }
+    }
+  }
+  async executeBeforeIdentify(identity) {
+    let data = void 0;
+    for (const hook of this.hooks) {
+      if (hook.beforeIdentify) {
+        data = await hook.beforeIdentify(identity) ?? data;
+      }
+    }
+    return data;
+  }
+  async executeAfterIdentify(identity, data) {
+    for (const hook of this.hooks) {
+      if (hook.afterIdentify) {
+        await hook.afterIdentify(identity, data);
+      }
+    }
+  }
+  async executeAfterRefresh(flags) {
+    for (const hook of this.hooks) {
+      if (hook.afterRefresh) {
+        await hook.afterRefresh(flags);
+      }
+    }
+  }
+};
+var ElectronTogglyClient = class {
+  config;
+  cache;
+  hookExecutor = new HookExecutor();
+  jwksCache = new InMemoryJwksCache();
+  fetchImpl;
+  listeners = /* @__PURE__ */ new Set();
+  features = {};
+  hasLoadedFlags = false;
+  identity;
+  groups = [];
+  claims = {};
+  cachedDefinitionsRevision = null;
+  pendingDefinitionsPin = null;
+  disposed = false;
+  refreshTimer = null;
+  refreshDebounceTimer = null;
+  ws = null;
+  wsConnected = false;
+  wsReconnectTimer = null;
+  wsReconnectAttempt = 0;
+  lastFallbackRefresh = 0;
+  localGates = [];
+  localGateIndex = /* @__PURE__ */ new Map();
+  initPromise = null;
+  constructor(config) {
+    if (!config.userDataPath) {
+      throw new Error('userDataPath is required (pass app.getPath("userData"))');
+    }
+    this.config = {
+      baseURI: config.baseURI ?? DEFAULT_BASE_URI,
+      environment: config.environment ?? DEFAULT_ENVIRONMENT,
+      connectTimeout: config.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT,
+      featureFlagsRefreshInterval: config.featureFlagsRefreshInterval ?? DEFAULT_REFRESH_INTERVAL,
+      verifySignatures: config.verifySignatures ?? false,
+      isDebug: config.isDebug ?? false,
+      enableLiveUpdates: config.enableLiveUpdates ?? Boolean(config.appKey),
+      ...config,
+      userDataPath: config.userDataPath
+    };
+    this.cache = new DiskFeatureCache(this.config.userDataPath);
+    this.fetchImpl = config.fetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : (() => {
+      throw new Error("fetch is not available; provide config.fetch");
+    })());
+    this.identity = config.identity ?? randomUUID();
+    this.groups = config.groups ? [...config.groups] : [];
+    this.claims = config.claims ? { ...config.claims } : {};
+    if (config.hooks) {
+      for (const hook of config.hooks) {
+        this.hookExecutor.addHook(hook);
+      }
+    }
+  }
+  addHook(hook) {
+    this.hookExecutor.addHook(hook);
+  }
+  onFlagsUpdated(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notifyFlagsUpdated() {
+    const snapshot = this.getBooleanFlags();
+    for (const listener of this.listeners) {
+      try {
+        listener(snapshot);
+      } catch (error) {
+        this.reportError("Flags updated listener error", error);
+      }
+    }
+  }
+  reportError(message, error) {
+    this.config.onError?.(message, error);
+    if (this.config.isDebug) {
+      console.warn(`[Toggly] ${message}`, error);
+    }
+  }
+  get contextCacheKey() {
+    const claims = this.claims;
+    return `v2:${encodeURIComponent(
+      JSON.stringify([
+        this.identity ?? "",
+        [...this.groups].sort((a, b) => a.localeCompare(b)),
+        Object.entries(claims).sort(([a], [b]) => a.localeCompare(b))
+      ])
+    )}`;
+  }
+  getBooleanFlags() {
+    return toBooleanDefinitions(this.features);
+  }
+  getFallbackFlags() {
+    if (this.hasLoadedFlags) {
+      return this.features;
+    }
+    const defaults = this.config.flagDefaults ?? {};
+    return { ...defaults };
+  }
+  buildEvaluatedUrl() {
+    const base = this.config.baseURI.replace(/\/$/, "");
+    const url = new URL(
+      `${base}/evaluated-signed/${this.config.appKey}/${this.config.environment}`
+    );
+    appendEvaluationContext(
+      url,
+      {
+        identity: this.identity,
+        groups: this.groups,
+        claims: this.claims
+      },
+      "evaluated"
+    );
+    return url.toString();
+  }
+  buildFetchHeaders(skipIfNoneMatch = false) {
+    const revision = skipIfNoneMatch ? null : this.cachedDefinitionsRevision;
+    return buildDefinitionFetchHeaders(
+      revision ? { "If-None-Match": revision, Accept: "application/json" } : { Accept: "application/json" }
+    );
+  }
+  applyRevision(response) {
+    const revision = extractDefinitionsRevision(response);
+    if (revision) {
+      this.cachedDefinitionsRevision = revision.replace(/^"+|"+$/g, "");
+    }
+  }
+  async persistCache() {
+    if (!this.config.appKey) {
+      return;
+    }
+    try {
+      await this.cache.write(
+        this.config.appKey,
+        this.config.environment,
+        this.contextCacheKey,
+        {
+          flags: this.features,
+          revision: this.cachedDefinitionsRevision,
+          updatedAt: Date.now()
+        }
+      );
+    } catch (error) {
+      this.reportError("Failed to write disk cache", error);
+    }
+  }
+  async loadDiskCache() {
+    if (!this.config.appKey) {
+      return false;
+    }
+    try {
+      const entry = await this.cache.read(
+        this.config.appKey,
+        this.config.environment,
+        this.contextCacheKey
+      );
+      if (!entry) {
+        return false;
+      }
+      this.features = entry.flags;
+      this.cachedDefinitionsRevision = entry.revision;
+      this.hasLoadedFlags = true;
+      return true;
+    } catch (error) {
+      this.reportError("Failed to read disk cache", error);
+      return false;
+    }
+  }
+  resolveEffectiveFlag(key, entityContext) {
+    const resolved = resolveEvaluatedDefinition(
+      this.features[key],
+      entityContext,
+      this.config.flagDefaults?.[key] ?? false
+    );
+    return applyLocalGate(resolved, key, this.localGates, this.localGateIndex);
+  }
+  isFeatureOn(key, entityContext, kind) {
+    const ctx = normalizeEntityContext(entityContext, kind);
+    void this.runEvaluationHooks(key, () => this.resolveEffectiveFlag(key, ctx));
+    return this.resolveEffectiveFlag(key, ctx);
+  }
+  isFeatureOff(key, entityContext, kind) {
+    return !this.isFeatureOn(key, entityContext, kind);
+  }
+  evaluateFeatureGate(keys, requirement = "all", negate = false, entityContext, kind) {
+    const ctx = normalizeEntityContext(entityContext, kind);
+    const req = requirement === "any" ? "any" : "all";
+    if (keys.length === 0) {
+      return !negate;
+    }
+    if (Object.keys(this.features).length === 0) {
+      const closed = negate;
+      void this.runEvaluationHooks(keys[0], () => closed);
+      return closed;
+    }
+    const isEnabled = (key) => this.resolveEffectiveFlag(key, ctx);
+    let gated;
+    if (req === "any") {
+      const anyOn = keys.some(isEnabled);
+      gated = negate ? !anyOn : anyOn;
+    } else {
+      const allOn = keys.every(isEnabled);
+      gated = negate ? !allOn : allOn;
+    }
+    if (this.localGates.length === 0) {
+      gated = evaluateEvaluatedGate(this.features, keys, req, negate, ctx);
+    }
+    void this.runEvaluationHooks(keys[0], () => gated);
+    return gated;
+  }
+  async runEvaluationHooks(flagKey, evaluate) {
+    try {
+      const data = await this.hookExecutor.executeBeforeEvaluation(flagKey);
+      const result = evaluate();
+      await this.hookExecutor.executeAfterEvaluation(flagKey, data, result);
+    } catch (error) {
+      this.reportError("Hook execution error", error);
+    }
+  }
+  getFlags() {
+    return this.getBooleanFlags();
+  }
+  setLocalGates(gates) {
+    this.localGates = [...gates];
+    this.localGateIndex = buildFlagGateIndex(this.localGates);
+  }
+  async refresh() {
+    if (this.disposed) {
+      return this.getBooleanFlags();
+    }
+    if (!this.config.appKey) {
+      this.features = { ...this.config.flagDefaults ?? {} };
+      this.hasLoadedFlags = true;
+      this.notifyFlagsUpdated();
+      return this.getBooleanFlags();
+    }
+    try {
+      const pin = this.pendingDefinitionsPin;
+      this.pendingDefinitionsPin = null;
+      const url = appendDefinitionsRevisionParam(this.buildEvaluatedUrl(), pin);
+      const headers = this.buildFetchHeaders(Boolean(pin));
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.config.connectTimeout
+      );
+      const response = await this.fetchImpl(url, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 304) {
+        this.applyRevision(response);
+        await this.persistCache();
+        return this.getBooleanFlags();
+      }
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status} ${response.statusText}`);
+      }
+      const bodyText = await readResponseBody(response);
+      const parsed = await parseEvaluatedResponseBody(bodyText, {
+        verifySignatures: this.config.verifySignatures,
+        baseURI: this.config.baseURI,
+        allowedKeyIds: this.config.allowedKeyIds,
+        maxSignatureAgeSeconds: this.config.maxSignatureAgeSeconds ?? void 0,
+        headers,
+        fetchImpl: this.fetchImpl,
+        getJwks: this.config.verifySignatures ? () => this.jwksCache.get({
+          verifySignatures: true,
+          baseURI: this.config.baseURI,
+          allowedKeyIds: this.config.allowedKeyIds,
+          maxSignatureAgeSeconds: this.config.maxSignatureAgeSeconds ?? void 0,
+          headers,
+          fetchImpl: this.fetchImpl
+        }) : void 0
+      });
+      const defs = (this.config.verifySignatures ? parsed : unwrapDefsPayload(parsed)) ?? {};
+      this.features = defs;
+      this.hasLoadedFlags = true;
+      this.applyRevision(response);
+      await this.persistCache();
+      await this.hookExecutor.executeAfterRefresh(this.getBooleanFlags());
+      this.notifyFlagsUpdated();
+      return this.getBooleanFlags();
+    } catch (error) {
+      this.reportError("Failed to refresh feature flags", error);
+      if (!this.hasLoadedFlags) {
+        const loaded = await this.loadDiskCache();
+        if (!loaded) {
+          this.features = this.getFallbackFlags();
+          this.hasLoadedFlags = true;
+        }
+      }
+      this.notifyFlagsUpdated();
+      return this.getBooleanFlags();
+    }
+  }
+  async init() {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this.doInit();
+    return this.initPromise;
+  }
+  async doInit() {
+    await this.loadDiskCache();
+    const flags = await this.refresh();
+    this.startRefreshInterval();
+    if (this.config.enableLiveUpdates && this.config.appKey) {
+      this.startWebSocket();
+    }
+    return flags;
+  }
+  async setContext(input) {
+    if (input.identity !== void 0) {
+      const data = await this.hookExecutor.executeBeforeIdentify(input.identity);
+      this.identity = input.identity;
+      await this.hookExecutor.executeAfterIdentify(input.identity, data);
+    }
+    if (input.groups !== void 0) {
+      this.groups = [...input.groups];
+    }
+    if (input.claims !== void 0) {
+      this.claims = { ...input.claims };
+    }
+    this.hasLoadedFlags = false;
+    this.cachedDefinitionsRevision = null;
+    return this.refresh();
+  }
+  async clearContext() {
+    this.identity = randomUUID();
+    this.groups = [];
+    this.claims = {};
+    this.hasLoadedFlags = false;
+    this.cachedDefinitionsRevision = null;
+    return this.refresh();
+  }
+  startRefreshInterval() {
+    this.stopRefreshInterval();
+    const interval = () => this.wsConnected ? FALLBACK_REFRESH_INTERVAL : this.config.featureFlagsRefreshInterval;
+    this.refreshTimer = setInterval(() => {
+      if (this.wsConnected) {
+        const elapsed = Date.now() - this.lastFallbackRefresh;
+        if (elapsed < FALLBACK_REFRESH_INTERVAL) {
+          return;
+        }
+      }
+      this.lastFallbackRefresh = Date.now();
+      void this.refresh();
+    }, Math.min(interval(), this.config.featureFlagsRefreshInterval));
+  }
+  stopRefreshInterval() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
+  scheduleDebouncedRefresh(forceJwksRefresh = false) {
+    if (this.refreshDebounceTimer) {
+      clearTimeout(this.refreshDebounceTimer);
+    }
+    this.refreshDebounceTimer = setTimeout(() => {
+      this.refreshDebounceTimer = null;
+      if (forceJwksRefresh && this.config.verifySignatures) {
+        this.cachedDefinitionsRevision = null;
+        this.jwksCache.clear();
+      }
+      void this.refresh();
+    }, REFRESH_DEBOUNCE_MS);
+  }
+  handleWsMessage(raw) {
+    try {
+      const message = JSON.parse(String(raw));
+      if (message.type === "ping") {
+        return;
+      }
+      if (shouldFetchOnSync(message, this.cachedDefinitionsRevision)) {
+        this.scheduleDebouncedRefresh();
+        return;
+      }
+      if (message.type === "sync" && message.etag) {
+        this.cachedDefinitionsRevision = message.etag;
+        return;
+      }
+      const plan = planFlagsUpdatedRefresh(message, this.cachedDefinitionsRevision);
+      applyFlagsUpdatedPlan(plan, message, {
+        refreshJwks: () => this.scheduleDebouncedRefresh(true),
+        refreshPinned: (pin) => {
+          this.pendingDefinitionsPin = pin;
+          this.cachedDefinitionsRevision = null;
+          this.scheduleDebouncedRefresh();
+        },
+        cacheEtagIfPresent: (etag) => {
+          this.cachedDefinitionsRevision = etag;
+        }
+      });
+    } catch (error) {
+      this.reportError("Failed to parse WebSocket message", error);
+    }
+  }
+  startWebSocket() {
+    if (this.disposed || !this.config.appKey || !this.config.enableLiveUpdates) {
+      return;
+    }
+    this.stopWebSocket(false);
+    const url = buildWebSocketUrl(
+      this.config.baseURI,
+      this.config.appKey,
+      this.cachedDefinitionsRevision
+    );
+    try {
+      const ws = new WebSocket(url);
+      this.ws = ws;
+      ws.on("open", () => {
+        this.wsConnected = true;
+        this.wsReconnectAttempt = 0;
+        this.lastFallbackRefresh = Date.now();
+        if (this.config.isDebug) {
+          console.log("[Toggly] WebSocket connected");
+        }
+      });
+      ws.on("message", (data) => this.handleWsMessage(data));
+      ws.on("close", () => {
+        this.wsConnected = false;
+        this.ws = null;
+        this.scheduleReconnect();
+      });
+      ws.on("error", (error) => {
+        this.reportError("WebSocket error", error);
+      });
+    } catch (error) {
+      this.reportError("Failed to start WebSocket", error);
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.disposed || !this.config.enableLiveUpdates) {
+      return;
+    }
+    if (this.wsReconnectTimer) {
+      return;
+    }
+    const delay = getNextReconnectDelayMs(this.wsReconnectAttempt);
+    this.wsReconnectAttempt += 1;
+    this.wsReconnectTimer = setTimeout(() => {
+      this.wsReconnectTimer = null;
+      this.startWebSocket();
+    }, delay);
+  }
+  stopWebSocket(clearReconnect = true) {
+    if (this.wsReconnectTimer && clearReconnect) {
+      clearTimeout(this.wsReconnectTimer);
+      this.wsReconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.removeAllListeners();
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.wsConnected = false;
+  }
+  close() {
+    this.disposed = true;
+    this.stopRefreshInterval();
+    if (this.refreshDebounceTimer) {
+      clearTimeout(this.refreshDebounceTimer);
+      this.refreshDebounceTimer = null;
+    }
+    this.stopWebSocket(true);
+    this.listeners.clear();
+    this.initPromise = null;
+  }
+};
+var singleton = null;
+async function initToggly(config) {
+  if (singleton) {
+    singleton.close();
+  }
+  singleton = new ElectronTogglyClient(config);
+  return singleton.init();
+}
+function getToggly() {
+  return singleton;
+}
+function isFeatureOn(key, entityContext, kind) {
+  return singleton?.isFeatureOn(key, entityContext, kind) ?? false;
+}
+function isFeatureOff(key, entityContext, kind) {
+  return singleton?.isFeatureOff(key, entityContext, kind) ?? true;
+}
+function evaluateFeatureGate(keys, requirement, negate, entityContext, kind) {
+  if (!singleton) {
+    return negate ?? false;
+  }
+  return singleton.evaluateFeatureGate(
+    keys,
+    requirement,
+    negate,
+    entityContext,
+    kind
+  );
+}
+async function setContext(input) {
+  if (!singleton) {
+    throw new Error("Toggly is not initialized. Call initToggly first.");
+  }
+  return singleton.setContext(input);
+}
+async function clearContext() {
+  if (!singleton) {
+    throw new Error("Toggly is not initialized. Call initToggly first.");
+  }
+  return singleton.clearContext();
+}
+function addHook(hook) {
+  singleton?.addHook(hook);
+}
+function closeToggly() {
+  singleton?.close();
+  singleton = null;
+}
+function __resetTogglyForTests() {
+  singleton?.close();
+  singleton = null;
+}
+
+// src/ipc-channels.ts
+var IPC_PREFIX = "toggly:";
+var IPC_CHANNELS = {
+  isFeatureOn: `${IPC_PREFIX}isFeatureOn`,
+  isFeatureOff: `${IPC_PREFIX}isFeatureOff`,
+  evaluateFeatureGate: `${IPC_PREFIX}evaluateFeatureGate`,
+  getFlags: `${IPC_PREFIX}getFlags`,
+  setContext: `${IPC_PREFIX}setContext`,
+  clearContext: `${IPC_PREFIX}clearContext`,
+  flagsUpdated: `${IPC_PREFIX}flags-updated`
+};
+
+// src/main/ipc.ts
+function registerTogglyIpc(ipcMain, getWindows = () => []) {
+  const client = getToggly();
+  if (!client) {
+    throw new Error("Toggly is not initialized. Call initToggly before registerTogglyIpc.");
+  }
+  ipcMain.on(IPC_CHANNELS.isFeatureOn, (event, key, entityContext, kind) => {
+    event.returnValue = isFeatureOn(
+      String(key),
+      entityContext,
+      kind
+    );
+  });
+  ipcMain.on(IPC_CHANNELS.isFeatureOff, (event, key, entityContext, kind) => {
+    event.returnValue = isFeatureOff(
+      String(key),
+      entityContext,
+      kind
+    );
+  });
+  ipcMain.on(
+    IPC_CHANNELS.evaluateFeatureGate,
+    (event, keys, requirement, negate, entityContext, kind) => {
+      event.returnValue = evaluateFeatureGate(
+        keys ?? [],
+        requirement,
+        Boolean(negate),
+        entityContext,
+        kind
+      );
+    }
+  );
+  ipcMain.handle(IPC_CHANNELS.getFlags, () => {
+    return getToggly()?.getFlags() ?? {};
+  });
+  ipcMain.handle(IPC_CHANNELS.setContext, (_event, context) => {
+    return setContext(context ?? {});
+  });
+  ipcMain.handle(IPC_CHANNELS.clearContext, () => {
+    return clearContext();
+  });
+  const unsubscribe = client.onFlagsUpdated((flags) => {
+    for (const win of getWindows()) {
+      try {
+        if (win.isDestroyed?.()) {
+          continue;
+        }
+        if (win.webContents.isDestroyed?.()) {
+          continue;
+        }
+        win.webContents.send(IPC_CHANNELS.flagsUpdated, flags);
+      } catch {
+      }
+    }
+  });
+  return () => {
+    unsubscribe();
+    ipcMain.removeAllListeners?.(IPC_CHANNELS.isFeatureOn);
+    ipcMain.removeAllListeners?.(IPC_CHANNELS.isFeatureOff);
+    ipcMain.removeAllListeners?.(IPC_CHANNELS.evaluateFeatureGate);
+    ipcMain.removeHandler?.(IPC_CHANNELS.getFlags);
+    ipcMain.removeHandler?.(IPC_CHANNELS.setContext);
+    ipcMain.removeHandler?.(IPC_CHANNELS.clearContext);
+  };
+}
+
+export { DiskFeatureCache, ElectronTogglyClient, IPC_CHANNELS, IPC_PREFIX, SDK_ID, SDK_VERSION, __resetTogglyForTests, addHook, buildCacheFilePath, clearContext, closeToggly, evaluateFeatureGate, getToggly, initToggly, isFeatureOff, isFeatureOn, registerTogglyIpc, setContext };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map