@infaris/flags 0.0.0-stage → 0.1.0

package/dist/client.js

@@ -0,0 +1,110 @@
+import {
+  FlagsError,
+  readEnv,
+  trimSlash
+} from "./chunk-LLGINDZS.js";
+import "./chunk-TRTQSARU.js";
+
+// src/client.ts
+var BrowserFlags = class {
+  url;
+  key;
+  environment;
+  options;
+  fetchImpl;
+  state;
+  loaded = false;
+  loading = null;
+  source = null;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    const env = readEnv();
+    const url = options.url ?? env?.NEXT_PUBLIC_INFARIS_FLAGS_URL;
+    const key = options.publishableKey ?? env?.NEXT_PUBLIC_INFARIS_FLAGS_KEY;
+    if (!url) throw new FlagsError("Missing url (set NEXT_PUBLIC_INFARIS_FLAGS_URL)", null, "missing_url");
+    if (!key) throw new FlagsError("Missing publishable key (set NEXT_PUBLIC_INFARIS_FLAGS_KEY)", null, "missing_key");
+    if (key.startsWith("ifr_fsk_")) throw new FlagsError("Never use the secret key in a browser; use the publishable key (ifr_fpk_\u2026)", null, "wrong_key");
+    this.url = trimSlash(url);
+    this.key = key;
+    this.environment = options.environment ?? "production";
+    this.options = options;
+    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    this.state = options.initial ?? { version: 0, flags: {}, items: {} };
+    this.loaded = !!options.initial;
+  }
+  get version() {
+    return this.state.version;
+  }
+  /** The current answer; stable between changes (safe for `useSyncExternalStore`). */
+  snapshot() {
+    return this.state;
+  }
+  async load() {
+    if (this.loading) return this.loading;
+    this.loading = (async () => {
+      try {
+        const token = await this.options.getAccessToken?.();
+        const res = await this.fetchImpl(`${this.url}/evaluate`, {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${this.key}`,
+            "content-type": "application/json",
+            ...token ? { "x-infaris-auth-token": token } : {}
+          },
+          body: JSON.stringify({ environment: this.environment, ...this.options.anonymousId ? { anonymousId: this.options.anonymousId } : {} })
+        });
+        if (!res.ok) throw new FlagsError(`Flags evaluate failed (HTTP ${res.status})`, res.status, "http_error");
+        this.state = await res.json();
+        this.loaded = true;
+        for (const listener of this.listeners) listener();
+      } finally {
+        this.loading = null;
+      }
+    })();
+    return this.loading;
+  }
+  getFlag(key, defaultValue = false) {
+    return Object.prototype.hasOwnProperty.call(this.state.flags, key) ? this.state.flags[key] : defaultValue;
+  }
+  getConfig(key, defaultValue) {
+    return Object.prototype.hasOwnProperty.call(this.state.items, key) ? this.state.items[key] : defaultValue;
+  }
+  /** Loads once, listens for new versions while anyone is subscribed. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (!this.loaded) void this.load().catch(() => void 0);
+    this.openStream();
+    return () => {
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0) {
+        this.source?.close();
+        this.source = null;
+      }
+    };
+  }
+  /** Ask again, e.g. after sign-in or sign-out (the token changed). */
+  reload() {
+    return this.load();
+  }
+  openStream() {
+    if (this.source || this.options.stream === false) return;
+    const ES = globalThis.EventSource;
+    if (!ES) return;
+    const source = new ES(`${this.url}/stream?key=${encodeURIComponent(this.key)}`);
+    source.addEventListener("version", (event) => {
+      try {
+        const { version } = JSON.parse(event.data);
+        if (version > this.state.version) void this.load().catch(() => void 0);
+      } catch {
+      }
+    });
+    this.source = source;
+  }
+};
+function createBrowserFlags(options = {}) {
+  return new BrowserFlags(options);
+}
+export {
+  BrowserFlags,
+  createBrowserFlags
+};

package/dist/index.cjs

@@ -0,0 +1,364 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../hosting-sdk/dist/index.cjs
+var require_dist = __commonJS({
+  "../hosting-sdk/dist/index.cjs"(exports2, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports2 = {};
+    __export2(index_exports2, {
+      InfarisError: () => InfarisError3
+    });
+    module2.exports = __toCommonJS2(index_exports2);
+    var errorBrand = /* @__PURE__ */ Symbol.for("@infaris/hosting-sdk/error");
+    var InfarisError3 = class _InfarisError extends Error {
+      // SDK bundles contain separate copies; catch the shared base across bundles and module formats.
+      static [Symbol.hasInstance](value) {
+        if (this !== _InfarisError) return Function.prototype[Symbol.hasInstance].call(this, value);
+        return value instanceof Error && errorBrand in value && value[errorBrand] === true;
+      }
+      code;
+      status;
+      constructor(message, code = "sdk_error", status = null) {
+        super(message);
+        Object.defineProperty(this, errorBrand, { value: true });
+        this.name = "InfarisError";
+        this.code = code;
+        this.status = status;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FlagsClient: () => FlagsClient,
+  FlagsError: () => FlagsError,
+  InfarisError: () => import_hosting_sdk2.InfarisError,
+  createClient: () => createFlagsClient,
+  createFlagsClient: () => createFlagsClient,
+  detectEnvironment: () => detectEnvironment,
+  evaluateFlag: () => evaluateFlag,
+  fnv1a32: () => fnv1a32,
+  rolloutBucket: () => rolloutBucket,
+  ruleMatches: () => ruleMatches
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/evaluate.ts
+function fnv1a32(input) {
+  const bytes = new TextEncoder().encode(input);
+  let hash = 2166136261;
+  for (const byte of bytes) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash >>> 0;
+}
+function rolloutBucket(flagKey, userId) {
+  return fnv1a32(`${flagKey}:${userId}`) % 1e4;
+}
+function attributeOf(ctx, attribute) {
+  switch (attribute) {
+    case "email":
+      return ctx.email ? ctx.email.trim().toLowerCase() : void 0;
+    case "emailDomain": {
+      const at = ctx.email ? ctx.email.lastIndexOf("@") : -1;
+      return at >= 0 ? ctx.email.slice(at + 1).trim().toLowerCase() : void 0;
+    }
+    case "userId":
+      return ctx.userId || void 0;
+    case "org":
+      return ctx.org || void 0;
+    case "role":
+      return ctx.role || void 0;
+  }
+}
+var caseless = (attribute) => attribute === "email" || attribute === "emailDomain";
+function ruleMatches(rule, ctx) {
+  const actual = attributeOf(ctx, rule.attribute);
+  if (actual === void 0) return false;
+  const values = caseless(rule.attribute) ? rule.values.map((v) => v.trim().toLowerCase()) : rule.values;
+  switch (rule.operator) {
+    case "in":
+      return values.includes(actual);
+    case "not_in":
+      return !values.includes(actual);
+    case "ends_with":
+      return values.some((v) => v.length > 0 && actual.endsWith(v));
+  }
+}
+function evaluateFlag(flag, environment, ctx) {
+  if (flag.killed) return { value: false, reason: "killed" };
+  const env = flag.environments[environment];
+  if (!env || !env.enabled) return { value: false, reason: "off" };
+  for (const rule of env.rules) {
+    if (ruleMatches(rule, ctx)) return { value: rule.serve, reason: "rule" };
+  }
+  if (env.rollout === null || env.rollout >= 100) return { value: true, reason: "fallthrough" };
+  if (env.rollout <= 0) return { value: false, reason: "rollout" };
+  if (!ctx.userId) return { value: false, reason: "no_user" };
+  return { value: rolloutBucket(flag.key, ctx.userId) < Math.round(env.rollout * 100), reason: "rollout" };
+}
+
+// src/types.ts
+var import_hosting_sdk = __toESM(require_dist(), 1);
+var FlagsError = class extends import_hosting_sdk.InfarisError {
+  constructor(message, status, code) {
+    super(message, code, status);
+    this.status = status;
+    this.code = code;
+    this.name = "FlagsError";
+  }
+  status;
+  code;
+};
+function detectEnvironment(env = readEnv()) {
+  const raw = (env?.INFARIS_ENV ?? env?.VERCEL_ENV ?? env?.NODE_ENV ?? "production").toLowerCase();
+  if (raw === "preview") return "preview";
+  if (raw === "development" || raw === "dev" || raw === "test" || raw === "local") return "development";
+  return "production";
+}
+function readEnv() {
+  const p = globalThis.process;
+  return p?.env;
+}
+function parseSseVersions(buffer) {
+  const versions = [];
+  const events = buffer.split(/\r?\n\r?\n/);
+  const rest = events.pop() ?? "";
+  for (const event of events) {
+    let name = "message";
+    let data = "";
+    for (const line of event.split(/\r?\n/)) {
+      if (line.startsWith("event:")) name = line.slice(6).trim();
+      else if (line.startsWith("data:")) data += line.slice(5).trim();
+    }
+    if (name !== "version" || !data) continue;
+    try {
+      const parsed = JSON.parse(data);
+      if (typeof parsed.version === "number") versions.push(parsed.version);
+    } catch {
+    }
+  }
+  return { versions, rest };
+}
+function trimSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+
+// src/server.ts
+var FlagsClient = class {
+  environment;
+  url;
+  key;
+  fetchImpl;
+  refreshMs;
+  onError;
+  snapshot = null;
+  etag = null;
+  checkedAt = 0;
+  loading = null;
+  streamAbort = null;
+  streaming = false;
+  closed = false;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    const env = readEnv();
+    const url = options.url ?? env?.INFARIS_FLAGS_URL;
+    const key = options.secretKey ?? env?.INFARIS_FLAGS_SECRET_KEY;
+    if (!url) throw new FlagsError("Missing url (set INFARIS_FLAGS_URL)", null, "missing_url");
+    if (!key) throw new FlagsError("Missing secret key (set INFARIS_FLAGS_SECRET_KEY)", null, "missing_key");
+    if (!key.startsWith("ifr_fsk_")) throw new FlagsError("The server client needs the secret key (ifr_fsk_\u2026)", null, "wrong_key");
+    this.url = trimSlash(url);
+    this.key = key;
+    this.environment = options.environment ?? detectEnvironment(env);
+    this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+    this.refreshMs = options.refreshIntervalMs ?? 3e4;
+    this.onError = options.onError ?? (() => void 0);
+    if (options.stream ?? true) this.streaming = true;
+  }
+  /** The version in memory (0 before the first load). */
+  get version() {
+    return this.snapshot?.version ?? 0;
+  }
+  /** Loads the first snapshot (and opens the stream). Every getter calls it, so calling it yourself is optional. */
+  async ready() {
+    if (this.snapshot) {
+      if (Date.now() - this.checkedAt > this.refreshMs && !this.loading) void this.refresh().catch(this.onError);
+      return;
+    }
+    await this.refresh();
+    if (this.streaming && !this.streamAbort) this.openStream();
+  }
+  /** Fetches the snapshot when it changed (`If-None-Match`). */
+  async refresh() {
+    if (this.loading) return this.loading;
+    this.loading = (async () => {
+      try {
+        const res = await this.fetchImpl(`${this.url}/snapshot`, {
+          headers: { authorization: `Bearer ${this.key}`, ...this.etag ? { "if-none-match": this.etag } : {} }
+        });
+        this.checkedAt = Date.now();
+        if (res.status === 304 && this.snapshot) return;
+        if (!res.ok) throw new FlagsError(`Flags snapshot failed (HTTP ${res.status})`, res.status, "http_error");
+        const next = await res.json();
+        const changed = next.version !== this.snapshot?.version;
+        this.snapshot = next;
+        this.etag = res.headers.get("etag");
+        if (changed) for (const listener of this.listeners) listener(next.version);
+      } finally {
+        this.loading = null;
+      }
+    })();
+    return this.loading;
+  }
+  /** The value of a flag for this user; `defaultValue` for an unknown flag or before Hosting answered once. */
+  async getFlag(key, context = {}, defaultValue = false) {
+    try {
+      await this.ready();
+    } catch (error) {
+      this.onError(error);
+      if (!this.snapshot) return defaultValue;
+    }
+    return this.getFlagSync(key, context, defaultValue);
+  }
+  /** From memory only (no request): for hot paths once `ready()` resolved. */
+  getFlagSync(key, context = {}, defaultValue = false) {
+    const result = this.evaluate(key, context);
+    return result ? result.value : defaultValue;
+  }
+  /** Value and reason, or null for an unknown flag. */
+  evaluate(key, context = {}) {
+    const flag = this.snapshot?.flags.find((f) => f.key === key);
+    return flag ? evaluateFlag(flag, this.environment, context) : null;
+  }
+  /** Every flag for this user. */
+  async getAll(context = {}) {
+    await this.ready().catch(this.onError);
+    const out = {};
+    for (const flag of this.snapshot?.flags ?? []) out[flag.key] = evaluateFlag(flag, this.environment, context).value;
+    return out;
+  }
+  /** An Edge Config value. */
+  async getConfig(key, defaultValue) {
+    await this.ready().catch(this.onError);
+    const items = this.snapshot?.items ?? {};
+    return Object.prototype.hasOwnProperty.call(items, key) ? items[key] : defaultValue;
+  }
+  /** Called with the new version after every change that reached this process. */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  close() {
+    this.closed = true;
+    this.streamAbort?.abort();
+    this.streamAbort = null;
+  }
+  openStream() {
+    if (this.closed) return;
+    const abort = new AbortController();
+    this.streamAbort = abort;
+    void (async () => {
+      let delay = 1e3;
+      while (!abort.signal.aborted) {
+        try {
+          const res = await this.fetchImpl(`${this.url}/stream`, {
+            headers: { authorization: `Bearer ${this.key}`, accept: "text/event-stream" },
+            signal: abort.signal
+          });
+          if (!res.ok || !res.body) throw new FlagsError(`Flags stream failed (HTTP ${res.status})`, res.status, "stream_failed");
+          delay = 1e3;
+          const reader = res.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+          for (; ; ) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const parsed = parseSseVersions(buffer);
+            buffer = parsed.rest;
+            if (parsed.versions.some((v) => v > this.version)) await this.refresh().catch(this.onError);
+            else this.checkedAt = Date.now();
+          }
+        } catch (error) {
+          if (abort.signal.aborted) return;
+          this.onError(error);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, 3e4);
+      }
+    })();
+  }
+};
+function createFlagsClient(options = {}) {
+  return new FlagsClient(options);
+}
+
+// src/index.ts
+var import_hosting_sdk2 = __toESM(require_dist(), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlagsClient,
+  FlagsError,
+  InfarisError,
+  createClient,
+  createFlagsClient,
+  detectEnvironment,
+  evaluateFlag,
+  fnv1a32,
+  rolloutBucket,
+  ruleMatches
+});

package/dist/index.d.cts

@@ -0,0 +1,61 @@
+import { a as FlagEnvironment, b as FetchLike, F as FlagContext, c as FlagReason, C as ConfigValue } from './types-DMIusvFt.cjs';
+export { E as EvaluatedFlags, d as FlagDefinition, e as FlagsError, f as FlagsSnapshot, I as InfarisError, g as detectEnvironment, h as evaluateFlag, i as fnv1a32, r as rolloutBucket, j as ruleMatches } from './types-DMIusvFt.cjs';
+
+interface FlagsClientOptions {
+    /** `INFARIS_FLAGS_URL` by default (`https://…/flags/v1/<ref>`). */
+    url?: string;
+    /** `INFARIS_FLAGS_SECRET_KEY` by default. */
+    secretKey?: string;
+    /** `INFARIS_ENV`, `VERCEL_ENV` or `NODE_ENV` by default. */
+    environment?: FlagEnvironment;
+    /** Keep a stream open for push invalidation (default true). Off in short-lived functions if you prefer polling. */
+    stream?: boolean;
+    /** Longest a snapshot is used without asking for a newer version (default 30 s). */
+    refreshIntervalMs?: number;
+    fetch?: FetchLike;
+    onError?: (error: unknown) => void;
+}
+declare class FlagsClient {
+    readonly environment: FlagEnvironment;
+    private readonly url;
+    private readonly key;
+    private readonly fetchImpl;
+    private readonly refreshMs;
+    private readonly onError;
+    private snapshot;
+    private etag;
+    private checkedAt;
+    private loading;
+    private streamAbort;
+    private streaming;
+    private closed;
+    private listeners;
+    constructor(options?: FlagsClientOptions);
+    /** The version in memory (0 before the first load). */
+    get version(): number;
+    /** Loads the first snapshot (and opens the stream). Every getter calls it, so calling it yourself is optional. */
+    ready(): Promise<void>;
+    /** Fetches the snapshot when it changed (`If-None-Match`). */
+    refresh(): Promise<void>;
+    /** The value of a flag for this user; `defaultValue` for an unknown flag or before Hosting answered once. */
+    getFlag(key: string, context?: FlagContext, defaultValue?: boolean): Promise<boolean>;
+    /** From memory only (no request): for hot paths once `ready()` resolved. */
+    getFlagSync(key: string, context?: FlagContext, defaultValue?: boolean): boolean;
+    /** Value and reason, or null for an unknown flag. */
+    evaluate(key: string, context?: FlagContext): {
+        value: boolean;
+        reason: FlagReason;
+    } | null;
+    /** Every flag for this user. */
+    getAll(context?: FlagContext): Promise<Record<string, boolean>>;
+    /** An Edge Config value. */
+    getConfig<T extends ConfigValue = ConfigValue>(key: string, defaultValue?: T): Promise<T | undefined>;
+    /** Called with the new version after every change that reached this process. */
+    onChange(listener: (version: number) => void): () => void;
+    close(): void;
+    private openStream;
+}
+/** One client per process: create it at module level and reuse it. */
+declare function createFlagsClient(options?: FlagsClientOptions): FlagsClient;
+
+export { ConfigValue, FetchLike, FlagContext, FlagEnvironment, FlagReason, FlagsClient, type FlagsClientOptions, createFlagsClient as createClient, createFlagsClient };

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { a as FlagEnvironment, b as FetchLike, F as FlagContext, c as FlagReason, C as ConfigValue } from './types-DMIusvFt.js';
+export { E as EvaluatedFlags, d as FlagDefinition, e as FlagsError, f as FlagsSnapshot, I as InfarisError, g as detectEnvironment, h as evaluateFlag, i as fnv1a32, r as rolloutBucket, j as ruleMatches } from './types-DMIusvFt.js';
+
+interface FlagsClientOptions {
+    /** `INFARIS_FLAGS_URL` by default (`https://…/flags/v1/<ref>`). */
+    url?: string;
+    /** `INFARIS_FLAGS_SECRET_KEY` by default. */
+    secretKey?: string;
+    /** `INFARIS_ENV`, `VERCEL_ENV` or `NODE_ENV` by default. */
+    environment?: FlagEnvironment;
+    /** Keep a stream open for push invalidation (default true). Off in short-lived functions if you prefer polling. */
+    stream?: boolean;
+    /** Longest a snapshot is used without asking for a newer version (default 30 s). */
+    refreshIntervalMs?: number;
+    fetch?: FetchLike;
+    onError?: (error: unknown) => void;
+}
+declare class FlagsClient {
+    readonly environment: FlagEnvironment;
+    private readonly url;
+    private readonly key;
+    private readonly fetchImpl;
+    private readonly refreshMs;
+    private readonly onError;
+    private snapshot;
+    private etag;
+    private checkedAt;
+    private loading;
+    private streamAbort;
+    private streaming;
+    private closed;
+    private listeners;
+    constructor(options?: FlagsClientOptions);
+    /** The version in memory (0 before the first load). */
+    get version(): number;
+    /** Loads the first snapshot (and opens the stream). Every getter calls it, so calling it yourself is optional. */
+    ready(): Promise<void>;
+    /** Fetches the snapshot when it changed (`If-None-Match`). */
+    refresh(): Promise<void>;
+    /** The value of a flag for this user; `defaultValue` for an unknown flag or before Hosting answered once. */
+    getFlag(key: string, context?: FlagContext, defaultValue?: boolean): Promise<boolean>;
+    /** From memory only (no request): for hot paths once `ready()` resolved. */
+    getFlagSync(key: string, context?: FlagContext, defaultValue?: boolean): boolean;
+    /** Value and reason, or null for an unknown flag. */
+    evaluate(key: string, context?: FlagContext): {
+        value: boolean;
+        reason: FlagReason;
+    } | null;
+    /** Every flag for this user. */
+    getAll(context?: FlagContext): Promise<Record<string, boolean>>;
+    /** An Edge Config value. */
+    getConfig<T extends ConfigValue = ConfigValue>(key: string, defaultValue?: T): Promise<T | undefined>;
+    /** Called with the new version after every change that reached this process. */
+    onChange(listener: (version: number) => void): () => void;
+    close(): void;
+    private openStream;
+}
+/** One client per process: create it at module level and reuse it. */
+declare function createFlagsClient(options?: FlagsClientOptions): FlagsClient;
+
+export { ConfigValue, FetchLike, FlagContext, FlagEnvironment, FlagReason, FlagsClient, type FlagsClientOptions, createFlagsClient as createClient, createFlagsClient };

package/dist/index.js

@@ -0,0 +1,32 @@
+import {
+  FlagsClient,
+  createFlagsClient,
+  evaluateFlag,
+  fnv1a32,
+  rolloutBucket,
+  ruleMatches
+} from "./chunk-RZ6DL2QZ.js";
+import {
+  FlagsError,
+  detectEnvironment,
+  require_dist
+} from "./chunk-LLGINDZS.js";
+import {
+  __toESM
+} from "./chunk-TRTQSARU.js";
+
+// src/index.ts
+var import_hosting_sdk = __toESM(require_dist(), 1);
+var export_InfarisError = import_hosting_sdk.InfarisError;
+export {
+  FlagsClient,
+  FlagsError,
+  export_InfarisError as InfarisError,
+  createFlagsClient as createClient,
+  createFlagsClient,
+  detectEnvironment,
+  evaluateFlag,
+  fnv1a32,
+  rolloutBucket,
+  ruleMatches
+};

package/dist/react.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  FlagsProvider: () => FlagsProvider,
+  useConfig: () => useConfig,
+  useFlag: () => useFlag,
+  useFlags: () => useFlags
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = require("react");
+var FlagsContext = (0, import_react.createContext)(null);
+function FlagsProvider({ client, children }) {
+  return (0, import_react.createElement)(FlagsContext.Provider, { value: client }, children);
+}
+function useFlagsState() {
+  const client = (0, import_react.useContext)(FlagsContext);
+  if (!client) throw new Error("useFlag needs a <FlagsProvider client={\u2026}> above it");
+  return (0, import_react.useSyncExternalStore)(
+    (onChange) => client.subscribe(onChange),
+    () => client.snapshot(),
+    () => client.snapshot()
+  );
+}
+function useFlag(key, defaultValue = false) {
+  const state = useFlagsState();
+  return Object.prototype.hasOwnProperty.call(state.flags, key) ? state.flags[key] : defaultValue;
+}
+function useFlags() {
+  return useFlagsState();
+}
+function useConfig(key, defaultValue) {
+  const state = useFlagsState();
+  return Object.prototype.hasOwnProperty.call(state.items, key) ? state.items[key] : defaultValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlagsProvider,
+  useConfig,
+  useFlag,
+  useFlags
+});