posthog-flag-toolkit 0.1.0

package/dist/index.js

@@ -0,0 +1,647 @@
+// src/guardian/decision.ts
+function fmtPct(n) {
+  if (n == null) return "\u2014";
+  return `${(n * 100).toFixed(2)}%`;
+}
+function detectRegression(metrics, thresholds) {
+  const { treatment, control } = metrics;
+  if (treatment.errorRate != null && control.errorRate != null && control.errorRate > 0 && treatment.errorRate / control.errorRate >= thresholds.errorRateRatioThreshold) {
+    const ratio = treatment.errorRate / control.errorRate;
+    return {
+      kind: "regression_detected",
+      reason: `error rate ratio ${ratio.toFixed(2)}x (${fmtPct(treatment.errorRate)} vs ${fmtPct(control.errorRate)})`
+    };
+  }
+  if (treatment.errorRate != null && treatment.errorRate > 0.01 && (control.errorRate == null || control.errorRate === 0)) {
+    return {
+      kind: "regression_detected",
+      reason: `treatment error rate ${fmtPct(treatment.errorRate)} vs control 0%`
+    };
+  }
+  if (treatment.publishSuccessRate != null && control.publishSuccessRate != null && control.publishSuccessRate - treatment.publishSuccessRate >= thresholds.publishSuccessDropThreshold) {
+    const drop = control.publishSuccessRate - treatment.publishSuccessRate;
+    return {
+      kind: "regression_detected",
+      reason: `publish success drop ${(drop * 100).toFixed(1)}pp (${fmtPct(treatment.publishSuccessRate)} vs ${fmtPct(control.publishSuccessRate)})`
+    };
+  }
+  return { kind: "no_regression", reason: "all metrics within thresholds" };
+}
+function meetsSampleFloor(metrics, thresholds) {
+  return metrics.treatment.eventCount >= thresholds.minSampleSize && metrics.treatment.uniqueUsers >= thresholds.minUniqueUsers && metrics.control.eventCount >= thresholds.minSampleSize && metrics.control.uniqueUsers >= thresholds.minUniqueUsers;
+}
+
+// src/logger.ts
+var consoleLogger = {
+  info: (msg, data) => console.log(`[posthog-flag-toolkit] ${msg}`, data ?? ""),
+  warn: (msg, data) => console.warn(`[posthog-flag-toolkit] ${msg}`, data ?? ""),
+  error: (msg, data) => console.error(`[posthog-flag-toolkit] ${msg}`, data ?? "")
+};
+
+// src/posthog/api.ts
+var DEFAULT_BASE_URL = "https://us.posthog.com";
+var MAX_RETRIES = 3;
+function baseUrl(config) {
+  return config.baseUrl ?? DEFAULT_BASE_URL;
+}
+function headers(config) {
+  return { Authorization: `Bearer ${config.apiKey}` };
+}
+function jsonHeaders(config) {
+  return {
+    ...headers(config),
+    "Content-Type": "application/json"
+  };
+}
+async function fetchWithRetry(url, init, retries = MAX_RETRIES) {
+  let attempt = 0;
+  while (true) {
+    const res = await fetch(url, init);
+    if (res.status !== 429 || attempt >= retries) return res;
+    attempt++;
+    const retryAfter = res.headers.get("Retry-After");
+    const waitMs = retryAfter ? Math.min(Number(retryAfter) * 1e3, 3e4) : Math.min(1e3 * 2 ** attempt, 3e4);
+    await new Promise((r) => setTimeout(r, waitMs));
+  }
+}
+async function fetchAllFlags(config) {
+  const flags = [];
+  let url = `${baseUrl(config)}/api/projects/${config.projectId}/feature_flags/?limit=200`;
+  while (url) {
+    const res = await fetchWithRetry(url, { headers: headers(config) });
+    if (!res.ok) {
+      throw new Error(
+        `PostHog flag fetch failed: ${res.status} ${await res.text().catch(() => "")}`
+      );
+    }
+    const data = await res.json();
+    flags.push(...data.results);
+    url = data.next;
+  }
+  return flags;
+}
+async function fetchFlagsByTag(config, tag) {
+  const res = await fetchWithRetry(
+    `${baseUrl(config)}/api/projects/${config.projectId}/feature_flags/?tags=${encodeURIComponent(tag)}&limit=200`,
+    { headers: headers(config) }
+  );
+  if (!res.ok) {
+    throw new Error(
+      `PostHog flag fetch by tag failed: ${res.status} ${await res.text().catch(() => "")}`
+    );
+  }
+  const data = await res.json();
+  return data.results;
+}
+async function fetchAllExperiments(config) {
+  const res = await fetchWithRetry(
+    `${baseUrl(config)}/api/projects/${config.projectId}/experiments/?limit=200`,
+    { headers: headers(config) }
+  );
+  if (!res.ok) return [];
+  const data = await res.json();
+  return data.results;
+}
+async function findTagAddedAt(config, flagId, tag) {
+  const res = await fetchWithRetry(
+    `${baseUrl(config)}/api/projects/${config.projectId}/feature_flags/${flagId}/activity/?limit=100`,
+    { headers: headers(config) }
+  );
+  if (!res.ok) return null;
+  const data = await res.json();
+  for (const entry of data.results) {
+    const changes = entry.detail?.changes ?? [];
+    for (const change of changes) {
+      if (change.field !== "tags") continue;
+      const before = Array.isArray(change.before) ? change.before : [];
+      const after = Array.isArray(change.after) ? change.after : [];
+      if (!before.includes(tag) && after.includes(tag)) {
+        return new Date(entry.created_at);
+      }
+    }
+  }
+  return null;
+}
+async function patchFlag(config, flagId, patch, options) {
+  if (options?.dryRun) return;
+  const res = await fetchWithRetry(
+    `${baseUrl(config)}/api/projects/${config.projectId}/feature_flags/${flagId}/`,
+    {
+      method: "PATCH",
+      headers: jsonHeaders(config),
+      body: JSON.stringify(patch)
+    }
+  );
+  if (!res.ok) {
+    throw new Error(`PostHog flag PATCH failed: ${res.status} ${await res.text().catch(() => "")}`);
+  }
+}
+async function patchFlagTags(config, flagId, tags, options) {
+  return patchFlag(config, flagId, { tags }, options);
+}
+async function createFlag(config, body, options) {
+  if (options?.dryRun) return null;
+  const payload = {
+    key: body.key,
+    name: body.name,
+    tags: body.tags,
+    active: body.active ?? false,
+    filters: body.filters ?? {
+      groups: [{ properties: [], rollout_percentage: 0 }]
+    },
+    creation_context: "feature_flags"
+  };
+  const res = await fetchWithRetry(
+    `${baseUrl(config)}/api/projects/${config.projectId}/feature_flags/`,
+    {
+      method: "POST",
+      headers: jsonHeaders(config),
+      body: JSON.stringify(payload)
+    }
+  );
+  if (!res.ok) {
+    throw new Error(
+      `PostHog flag CREATE failed: ${res.status} ${await res.text().catch(() => "")}`
+    );
+  }
+  return await res.json();
+}
+function isFullyReleased(flag) {
+  if (!flag.active || flag.deleted) return false;
+  const groups = flag.filters?.groups ?? [];
+  if (groups.length === 0) return false;
+  return groups.every((g) => (g.rollout_percentage ?? 100) === 100);
+}
+function hasTag(flag, tag) {
+  return (flag.tags ?? []).includes(tag);
+}
+function withTagAdded(flag, tag) {
+  const existing = flag.tags ?? [];
+  if (existing.includes(tag)) return existing;
+  return [...existing, tag];
+}
+
+// src/posthog/hogql.ts
+var FLAG_KEY_REGEX = /^[a-z0-9_-]+$/;
+function normalizeVariant(raw) {
+  if (raw == null) return "unknown";
+  const s = String(raw).toLowerCase();
+  if (s === "false" || s === "0") return "control";
+  if (s === "true" || s === "1") return "treatment";
+  return "unknown";
+}
+async function queryCohortMetrics(params) {
+  const { config, flagKey, windowStart, windowEnd } = params;
+  const publishEvent = params.publishEventName ?? "post/publish.completed";
+  const publishProp = params.publishSuccessProp ?? "properties.success";
+  if (!FLAG_KEY_REGEX.test(flagKey)) {
+    throw new Error(
+      `Invalid flag key for HogQL interpolation: "${flagKey}". Must match ${FLAG_KEY_REGEX}`
+    );
+  }
+  const baseUrl2 = config.baseUrl ?? "https://us.posthog.com";
+  const variantProp = `properties.$feature/${flagKey}`;
+  const hogql = `
+    SELECT
+      toString(${variantProp}) AS variant,
+      count() AS total_events,
+      count(DISTINCT distinct_id) AS unique_users,
+      countIf(event = '$exception') AS error_events,
+      countIf(event = '${publishEvent}' AND ${publishProp} = true) AS publish_successes,
+      countIf(event = '${publishEvent}') AS publish_total
+    FROM events
+    WHERE timestamp >= toDateTime('${windowStart.toISOString()}')
+      AND timestamp < toDateTime('${windowEnd.toISOString()}')
+      AND ${variantProp} IS NOT NULL
+    GROUP BY variant
+  `;
+  const res = await fetchWithRetry(`${baseUrl2}/api/projects/${config.projectId}/query/`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: { kind: "HogQLQuery", query: hogql }
+    })
+  });
+  if (!res.ok) {
+    throw new Error(
+      `PostHog HogQL query failed for ${flagKey}: ${res.status} ${await res.text().catch(() => "")}`
+    );
+  }
+  const data = await res.json();
+  const zero = {
+    eventCount: 0,
+    uniqueUsers: 0,
+    errorRate: null,
+    publishSuccessRate: null
+  };
+  const metrics = {
+    treatment: { ...zero },
+    control: { ...zero }
+  };
+  for (const row of data.results ?? []) {
+    const [variantRaw, totalEvents, uniqueUsers, errorEvents, publishSuccesses, publishTotal] = row;
+    const cohort = {
+      eventCount: Number(totalEvents ?? 0),
+      uniqueUsers: Number(uniqueUsers ?? 0),
+      errorRate: totalEvents > 0 ? Number(errorEvents ?? 0) / Number(totalEvents) : null,
+      publishSuccessRate: publishTotal > 0 ? Number(publishSuccesses ?? 0) / Number(publishTotal) : null
+    };
+    const variant = normalizeVariant(variantRaw);
+    if (variant === "treatment") metrics.treatment = cohort;
+    else if (variant === "control") metrics.control = cohort;
+  }
+  return metrics;
+}
+
+// src/step-runner.ts
+var SimpleStepRunner = class {
+  async run(_id, fn) {
+    return fn();
+  }
+};
+
+// src/guardian/thresholds.ts
+var DEFAULT_THRESHOLDS = {
+  windowMinutes: 20,
+  minSampleSize: 100,
+  minUniqueUsers: 50,
+  errorRateRatioThreshold: 2,
+  publishSuccessDropThreshold: 0.15,
+  cooldownMinutes: 30
+};
+function mergeThresholds(overrides) {
+  return { ...DEFAULT_THRESHOLDS, ...overrides };
+}
+
+// src/guardian/run-flag-guardian.ts
+var GUARDIAN_TAG = "guardian";
+var GUARDIAN_ENFORCE_TAG = "guardian-enforce";
+function isInCooldown(flag, cooldownMinutes) {
+  if (!flag.updated_at) return false;
+  const updated = new Date(flag.updated_at).getTime();
+  return Date.now() - updated < cooldownMinutes * 60 * 1e3;
+}
+function posthogFlagUrl(projectId, flagId, baseUrl2 = "https://us.posthog.com") {
+  return `${baseUrl2}/project/${projectId}/feature_flags/${flagId}`;
+}
+async function runFlagGuardian(options) {
+  const {
+    posthog,
+    step = new SimpleStepRunner(),
+    dryRun = false,
+    callbacks = {},
+    logger = consoleLogger
+  } = options;
+  const thresholds = mergeThresholds(options.thresholds);
+  logger.info("Flag guardian started");
+  const monitoredFlags = await step.run("fetch-guardian-flags", async () => {
+    const all = await fetchFlagsByTag(posthog, GUARDIAN_TAG);
+    return all.filter((f) => f.active && !f.deleted && hasTag(f, GUARDIAN_TAG));
+  });
+  const windowEnd = /* @__PURE__ */ new Date();
+  const windowStart = new Date(windowEnd.getTime() - thresholds.windowMinutes * 60 * 1e3);
+  const regressions = [];
+  const perFlagOutcomes = [];
+  for (const flag of monitoredFlags) {
+    const enforceEnabled = hasTag(flag, GUARDIAN_ENFORCE_TAG);
+    if (isInCooldown(flag, thresholds.cooldownMinutes)) {
+      perFlagOutcomes.push({
+        flag_key: flag.key,
+        decision: "insufficient_data",
+        reason: "cooldown"
+      });
+      continue;
+    }
+    const metrics = await step.run(`evaluate-${flag.id}`, async () => {
+      return queryCohortMetrics({
+        config: posthog,
+        flagKey: flag.key,
+        windowStart,
+        windowEnd,
+        publishEventName: options.publishEventName,
+        publishSuccessProp: options.publishSuccessProp
+      });
+    });
+    if (!meetsSampleFloor(metrics, thresholds)) {
+      perFlagOutcomes.push({
+        flag_key: flag.key,
+        decision: "insufficient_data",
+        reason: "sample_size"
+      });
+      continue;
+    }
+    const decision = detectRegression(metrics, thresholds);
+    if (decision.kind === "no_regression") {
+      const evaluation2 = {
+        flag,
+        metrics,
+        decision: "no_regression",
+        reason: decision.reason,
+        enforced: false
+      };
+      await callbacks.onEvaluated?.(evaluation2);
+      perFlagOutcomes.push({
+        flag_key: flag.key,
+        decision: "no_regression",
+        reason: decision.reason
+      });
+      continue;
+    }
+    let enforced = false;
+    if (enforceEnabled && !dryRun) {
+      await step.run(`enforce-${flag.id}`, async () => {
+        await patchFlag(posthog, flag.id, { active: false }, { dryRun });
+      });
+      enforced = true;
+    }
+    const finalDecision = enforced ? "auto_disabled" : "regression_detected";
+    const evaluation = {
+      flag,
+      metrics,
+      decision: finalDecision,
+      reason: decision.reason,
+      enforced
+    };
+    await callbacks.onEvaluated?.(evaluation);
+    if (decision.kind === "regression_detected") {
+      await callbacks.onRegression?.(evaluation);
+    }
+    if (enforced) {
+      await callbacks.onEnforced?.(flag, evaluation);
+    }
+    regressions.push(evaluation);
+    perFlagOutcomes.push({
+      flag_key: flag.key,
+      decision: finalDecision,
+      reason: decision.reason
+    });
+  }
+  const result = {
+    flags_evaluated: monitoredFlags.length,
+    regressions_detected: regressions.length,
+    auto_disabled: regressions.filter((r) => r.enforced).length,
+    outcomes: perFlagOutcomes
+  };
+  logger.info("Flag guardian completed", {
+    flags_evaluated: result.flags_evaluated,
+    regressions_detected: result.regressions_detected,
+    auto_disabled: result.auto_disabled
+  });
+  return result;
+}
+
+// src/registry/naming.ts
+function buildNamingRegex(areas) {
+  return new RegExp(`^(release|experiment|ops|tier)_(${areas.join("|")})_[a-z0-9_]+$`);
+}
+function getLifecycle(key) {
+  return key.split("_")[0];
+}
+function getArea(key) {
+  return key.split("_")[1];
+}
+
+// src/registry/define.ts
+function createRegistry(config) {
+  const NAMING_REGEX = buildNamingRegex(config.areas);
+  function flag(name, registry) {
+    return registry[name].key;
+  }
+  return {
+    NAMING_REGEX,
+    flag,
+    getLifecycle,
+    getArea: (key) => getArea(key)
+  };
+}
+
+// src/release-tracker/run-release-tracker.ts
+var RELEASED_TAG = "released-detected-v1";
+var STALE_THRESHOLD_DAYS = 30;
+function staleTagForNow() {
+  const now = /* @__PURE__ */ new Date();
+  const yyyy = now.getUTCFullYear();
+  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+  return `stale-notified-${yyyy}-${mm}`;
+}
+async function runReleaseTracker(options) {
+  const {
+    posthog,
+    registry,
+    namingRegex,
+    namingExemptTag = "naming-exempt",
+    staleThresholdDays = STALE_THRESHOLD_DAYS,
+    step = new SimpleStepRunner(),
+    dryRun = false,
+    callbacks = {},
+    logger = consoleLogger
+  } = options;
+  logger.info("Feature release tracker started");
+  const flags = await step.run("fetch-flags", () => fetchAllFlags(posthog));
+  const registryKeys = new Set(Object.values(registry).map((d) => d.key));
+  const orphans = flags.filter((f) => !f.deleted && !registryKeys.has(f.key)).map((f) => ({ key: f.key }));
+  const namingViolations = flags.filter((f) => !f.deleted && !hasTag(f, namingExemptTag) && !namingRegex.test(f.key)).map((f) => ({ key: f.key }));
+  for (const o of orphans) {
+    const posthogFlag = flags.find((f) => f.key === o.key);
+    if (posthogFlag) await callbacks.onOrphan?.(posthogFlag);
+  }
+  for (const v of namingViolations) {
+    const posthogFlag = flags.find((f) => f.key === v.key);
+    if (posthogFlag) await callbacks.onNamingViolation?.(posthogFlag);
+  }
+  const newlyReleased = flags.filter((f) => isFullyReleased(f) && !hasTag(f, RELEASED_TAG));
+  const newFlagReleases = [];
+  for (const flag of newlyReleased) {
+    await step.run(`tag-released-${flag.id}`, async () => {
+      await patchFlagTags(posthog, flag.id, withTagAdded(flag, RELEASED_TAG), {
+        dryRun
+      });
+    });
+    await callbacks.onNewRelease?.(flag, "flag");
+    newFlagReleases.push({
+      key: flag.key,
+      name: flag.name ?? flag.key,
+      type: "flag"
+    });
+  }
+  const experiments = await step.run(
+    "fetch-experiments",
+    () => fetchAllExperiments(posthog)
+  );
+  const newExperimentReleases = [];
+  const flagsByKey = new Map(flags.map((f) => [f.key, f]));
+  const now = Date.now();
+  const completedExperiments = experiments.filter((e) => {
+    if (e.archived) return false;
+    if (!e.end_date) return false;
+    return new Date(e.end_date).getTime() <= now;
+  });
+  for (const exp of completedExperiments) {
+    const linkedFlag = flagsByKey.get(exp.feature_flag_key);
+    if (!linkedFlag) continue;
+    if (hasTag(linkedFlag, RELEASED_TAG)) continue;
+    await step.run(`tag-experiment-released-${exp.id}`, async () => {
+      await patchFlagTags(posthog, linkedFlag.id, withTagAdded(linkedFlag, RELEASED_TAG), {
+        dryRun
+      });
+    });
+    await callbacks.onNewRelease?.(linkedFlag, "experiment");
+    newExperimentReleases.push({
+      key: exp.feature_flag_key,
+      name: exp.name,
+      type: "experiment"
+    });
+  }
+  const STALE_ELIGIBLE_LIFECYCLES = /* @__PURE__ */ new Set(["release", "experiment"]);
+  const staleTag = staleTagForNow();
+  const staleCandidates = flags.filter(
+    (f) => hasTag(f, RELEASED_TAG) && !hasTag(f, staleTag) && STALE_ELIGIBLE_LIFECYCLES.has(getLifecycle(f.key))
+  );
+  const staleFlags = [];
+  for (const flag of staleCandidates) {
+    const releasedAt = await step.run(`find-release-time-${flag.id}`, async () => {
+      const t = await findTagAddedAt(posthog, flag.id, RELEASED_TAG);
+      return t ? t.toISOString() : null;
+    });
+    if (!releasedAt) continue;
+    const days = Math.floor((now - new Date(releasedAt).getTime()) / (24 * 60 * 60 * 1e3));
+    if (days < staleThresholdDays) continue;
+    await step.run(`tag-stale-${flag.id}`, async () => {
+      await patchFlagTags(posthog, flag.id, withTagAdded(flag, staleTag), {
+        dryRun
+      });
+    });
+    await callbacks.onStale?.(flag, days);
+    staleFlags.push({
+      key: flag.key,
+      name: flag.name ?? flag.key,
+      daysSinceRelease: days
+    });
+  }
+  const anyNews = newFlagReleases.length + newExperimentReleases.length + staleFlags.length + orphans.length + namingViolations.length > 0;
+  if (anyNews) {
+    await callbacks.onDigestReady?.({
+      newFlagReleases,
+      newExperimentReleases,
+      staleFlags,
+      orphans,
+      namingViolations
+    });
+  }
+  const result = {
+    flags_checked: flags.length,
+    experiments_checked: experiments.length,
+    new_flag_releases: newFlagReleases.length,
+    new_experiment_releases: newExperimentReleases.length,
+    stale_flags_notified: staleFlags.length,
+    orphans: orphans.length,
+    naming_violations: namingViolations.length
+  };
+  logger.info("Feature release tracker completed", result);
+  return result;
+}
+
+// src/sync/run-flag-sync.ts
+function unionTags(current, wanted) {
+  const currentSet = new Set(current ?? []);
+  const merged = new Set(currentSet);
+  for (const t of wanted) merged.add(t);
+  if (merged.size === currentSet.size) return null;
+  return [...merged];
+}
+function initialTagsFor(def) {
+  const tags = new Set(def.tags ?? []);
+  if (def.guardian) tags.add("guardian");
+  return [...tags];
+}
+async function runFlagSync(options) {
+  const {
+    posthog,
+    registry,
+    namingRegex,
+    namingExemptTag = "naming-exempt",
+    step = new SimpleStepRunner(),
+    dryRun = false,
+    callbacks = {},
+    logger = consoleLogger
+  } = options;
+  logger.info("Feature flag sync started");
+  const posthogFlags = await step.run(
+    "fetch-posthog-flags",
+    () => fetchAllFlags(posthog)
+  );
+  const posthogByKey = new Map(posthogFlags.map((f) => [f.key, f]));
+  const registryEntries = Object.values(registry);
+  const registryKeys = new Set(registryEntries.map((d) => d.key));
+  const toCreate = registryEntries.filter((d) => !posthogByKey.has(d.key));
+  const toReconcile = registryEntries.filter((d) => posthogByKey.has(d.key)).flatMap((d) => {
+    const existing = posthogByKey.get(d.key);
+    if (!existing) return [];
+    return [{ def: d, existing }];
+  });
+  const orphans = posthogFlags.filter((f) => !f.deleted && !registryKeys.has(f.key));
+  const namingViolations = posthogFlags.filter(
+    (f) => !f.deleted && !hasTag(f, namingExemptTag) && !namingRegex.test(f.key)
+  );
+  const created = [];
+  for (const def of toCreate) {
+    await step.run(`create-${def.key}`, async () => {
+      const filters = {
+        groups: [{ properties: [], rollout_percentage: 0 }]
+      };
+      await createFlag(
+        posthog,
+        {
+          key: def.key,
+          name: def.description,
+          tags: initialTagsFor(def),
+          active: false,
+          filters
+        },
+        { dryRun }
+      );
+    });
+    created.push(def.key);
+    await callbacks.onCreate?.(def);
+  }
+  const reconciled = [];
+  for (const { def, existing } of toReconcile) {
+    const patch = {};
+    if (existing.name !== def.description) {
+      patch.name = def.description;
+    }
+    const wanted = [...def.tags ?? []];
+    if (def.guardian) wanted.push("guardian");
+    const newTags = unionTags(existing.tags, wanted);
+    if (newTags) patch.tags = newTags;
+    if (Object.keys(patch).length === 0) continue;
+    await step.run(`reconcile-${def.key}`, async () => {
+      await patchFlag(posthog, existing.id, patch, { dryRun });
+    });
+    reconciled.push(def.key);
+    await callbacks.onReconcile?.(existing, patch);
+  }
+  for (const orphan of orphans) {
+    await callbacks.onOrphan?.(orphan);
+  }
+  for (const violator of namingViolations) {
+    await callbacks.onNamingViolation?.(violator);
+  }
+  const result = {
+    registry_size: registryEntries.length,
+    posthog_size: posthogFlags.length,
+    created: created.length,
+    reconciled: reconciled.length,
+    orphans: orphans.length,
+    naming_violations: namingViolations.length
+  };
+  logger.info("Feature flag sync completed", result);
+  return result;
+}
+
+export { DEFAULT_THRESHOLDS, SimpleStepRunner, buildNamingRegex, consoleLogger, createFlag, createRegistry, detectRegression, fetchAllExperiments, fetchAllFlags, fetchFlagsByTag, findTagAddedAt, fmtPct, getArea, getLifecycle, hasTag, isFullyReleased, meetsSampleFloor, mergeThresholds, patchFlag, patchFlagTags, posthogFlagUrl, queryCohortMetrics, runFlagGuardian, runFlagSync, runReleaseTracker, withTagAdded };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map