@schematichq/schematic-react 1.4.1 → 1.6.0

package/dist/schematic-react.cjs.js

@@ -30,22 +30,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BillingDataProvider: () => BillingDataProvider,
+  BillingProvider: () => BillingProvider,
+  DEFAULT_INVOICE_QUERY: () => DEFAULT_INVOICE_QUERY,
+  INVOICE_PAGE_SIZE: () => INVOICE_PAGE_SIZE,
+  InvoiceStatus: () => InvoiceStatus,
   RuleType: () => RuleType,
   Schematic: () => Schematic,
+  SchematicI18nContext: () => SchematicI18nContext,
+  SchematicI18nProvider: () => SchematicI18nProvider,
   SchematicProvider: () => SchematicProvider,
   TrialStatus: () => TrialStatus,
   UsagePeriod: () => UsagePeriod,
+  normalizeInvoiceQuery: () => normalizeInvoiceQuery2,
+  useBillingDataSource: () => useBillingDataSource,
+  useInvalidateBillingData: () => useInvalidateBillingData,
+  useInvoices: () => useInvoices,
   useSchematic: () => useSchematic,
   useSchematicContext: () => useSchematicContext,
+  useSchematicCreditBalance: () => useSchematicCreditBalance,
   useSchematicEntitlement: () => useSchematicEntitlement,
   useSchematicEvents: () => useSchematicEvents,
   useSchematicFlag: () => useSchematicFlag,
+  useSchematicI18n: () => useSchematicI18n,
   useSchematicIsPending: () => useSchematicIsPending,
-  useSchematicPlan: () => useSchematicPlan
+  useSchematicLocale: () => useSchematicLocale,
+  useSchematicPlan: () => useSchematicPlan,
+  useSchematicStrings: () => useSchematicStrings,
+  useSchematicTranslate: () => useSchematicTranslate
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/@schematichq/schematic-js/dist/schematic.esm.js
+// node_modules/.pnpm/@schematichq+schematic-js@1.7.0/node_modules/@schematichq/schematic-js/dist/schematic.esm.js
 var __create2 = Object.create;
 var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -53,7 +69,15 @@ var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __getProtoOf2 = Object.getPrototypeOf;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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") {
@@ -72,7 +96,7 @@ var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__
   mod
 ));
 var require_browser_polyfill = __commonJS({
-  "node_modules/cross-fetch/dist/browser-polyfill.js"(exports) {
+  "node_modules/.pnpm/cross-fetch@4.1.0/node_modules/cross-fetch/dist/browser-polyfill.js"(exports) {
     (function(self2) {
       var irrelevant = (function(exports2) {
         var g = typeof globalThis !== "undefined" && globalThis || typeof self2 !== "undefined" && self2 || // eslint-disable-next-line no-undef
@@ -612,19 +636,16 @@ for (let i = 0; i < 256; ++i) {
 function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
-var getRandomValues;
 var rnds8 = new Uint8Array(16);
 function rng() {
-  if (!getRandomValues) {
-    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
-      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-    }
-    getRandomValues = crypto.getRandomValues.bind(crypto);
+  return crypto.getRandomValues(rnds8);
+}
+function v4(options, buf, offset) {
+  if (!buf && !options && crypto.randomUUID) {
+    return crypto.randomUUID();
   }
-  return getRandomValues(rnds8);
+  return _v4(options, buf, offset);
 }
-var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-var native_default = { randomUUID };
 function _v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random ?? options.rng?.() ?? rng();
@@ -645,12 +666,6 @@ function _v4(options, buf, offset) {
   }
   return unsafeStringify(rnds);
 }
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
 var v4_default = v4;
 var import_polyfill = __toESM2(require_browser_polyfill());
 function EntitlementValueTypeFromJSON(json) {
@@ -659,6 +674,30 @@ function EntitlementValueTypeFromJSON(json) {
 function EntitlementValueTypeFromJSONTyped(json, ignoreDiscriminator) {
   return json;
 }
+function MetricPeriodMonthResetFromJSON(json) {
+  return MetricPeriodMonthResetFromJSONTyped(json, false);
+}
+function MetricPeriodMonthResetFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function WarningTierFromJSON(json) {
+  return WarningTierFromJSONTyped(json, false);
+}
+function WarningTierFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    key: json["key"],
+    value: json["value"]
+  };
+}
+function MetricPeriodFromJSON(json) {
+  return MetricPeriodFromJSONTyped(json, false);
+}
+function MetricPeriodFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
 function FeatureEntitlementFromJSON(json) {
   return FeatureEntitlementFromJSONTyped(json, false);
 }
@@ -668,21 +707,32 @@ function FeatureEntitlementFromJSONTyped(json, ignoreDiscriminator) {
   }
   return {
     allocation: json["allocation"] == null ? void 0 : json["allocation"],
+    consumptionRate: json["consumption_rate"] == null ? void 0 : json["consumption_rate"],
     creditId: json["credit_id"] == null ? void 0 : json["credit_id"],
     creditRemaining: json["credit_remaining"] == null ? void 0 : json["credit_remaining"],
+    creditReserved: json["credit_reserved"] == null ? void 0 : json["credit_reserved"],
+    creditSettled: json["credit_settled"] == null ? void 0 : json["credit_settled"],
     creditTotal: json["credit_total"] == null ? void 0 : json["credit_total"],
     creditUsed: json["credit_used"] == null ? void 0 : json["credit_used"],
     eventName: json["event_name"] == null ? void 0 : json["event_name"],
+    eventSubtype: json["event_subtype"] == null ? void 0 : json["event_subtype"],
     featureId: json["feature_id"],
     featureKey: json["feature_key"],
-    metricPeriod: json["metric_period"] == null ? void 0 : json["metric_period"],
+    metricPeriod: json["metric_period"] == null ? void 0 : MetricPeriodFromJSON(json["metric_period"]),
     metricResetAt: json["metric_reset_at"] == null ? void 0 : new Date(json["metric_reset_at"]),
-    monthReset: json["month_reset"] == null ? void 0 : json["month_reset"],
+    monthReset: json["month_reset"] == null ? void 0 : MetricPeriodMonthResetFromJSON(json["month_reset"]),
     softLimit: json["soft_limit"] == null ? void 0 : json["soft_limit"],
     usage: json["usage"] == null ? void 0 : json["usage"],
-    valueType: EntitlementValueTypeFromJSON(json["value_type"])
+    valueType: EntitlementValueTypeFromJSON(json["value_type"]),
+    warningTiers: json["warning_tiers"] == null ? void 0 : json["warning_tiers"].map(WarningTierFromJSON)
   };
 }
+function RuleTypeFromJSON(json) {
+  return RuleTypeFromJSONTyped(json, false);
+}
+function RuleTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
 function CheckFlagResponseDataFromJSON(json) {
   return CheckFlagResponseDataFromJSONTyped(json, false);
 }
@@ -697,13 +747,13 @@ function CheckFlagResponseDataFromJSONTyped(json, ignoreDiscriminator) {
     featureAllocation: json["feature_allocation"] == null ? void 0 : json["feature_allocation"],
     featureUsage: json["feature_usage"] == null ? void 0 : json["feature_usage"],
     featureUsageEvent: json["feature_usage_event"] == null ? void 0 : json["feature_usage_event"],
-    featureUsagePeriod: json["feature_usage_period"] == null ? void 0 : json["feature_usage_period"],
+    featureUsagePeriod: json["feature_usage_period"] == null ? void 0 : MetricPeriodFromJSON(json["feature_usage_period"]),
     featureUsageResetAt: json["feature_usage_reset_at"] == null ? void 0 : new Date(json["feature_usage_reset_at"]),
     flag: json["flag"],
     flagId: json["flag_id"] == null ? void 0 : json["flag_id"],
     reason: json["reason"],
     ruleId: json["rule_id"] == null ? void 0 : json["rule_id"],
-    ruleType: json["rule_type"] == null ? void 0 : json["rule_type"],
+    ruleType: json["rule_type"] == null ? void 0 : RuleTypeFromJSON(json["rule_type"]),
     userId: json["user_id"] == null ? void 0 : json["user_id"],
     value: json["value"]
   };
@@ -720,6 +770,268 @@ function CheckFlagResponseFromJSONTyped(json, ignoreDiscriminator) {
     params: json["params"]
   };
 }
+var BASE_PATH = "https://api.schematichq.com".replace(/\/+$/, "");
+var Configuration = class {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  configuration;
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return void 0;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return void 0;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+};
+var DefaultConfig = new Configuration();
+var BaseAPI = class _BaseAPI {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  configuration;
+  static jsonRegex = new RegExp(
+    "^(:?application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(:?;.*)?$",
+    "i"
+  );
+  middleware;
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return _BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && response.status >= 200 && response.status < 300) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign(
+      {},
+      this.configuration.headers,
+      context.headers
+    );
+    Object.keys(headers).forEach(
+      (key) => headers[key] === void 0 ? delete headers[key] : {}
+    );
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = void 0;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(
+        fetchParams.url,
+        fetchParams.init
+      );
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : void 0
+          }) || response;
+        }
+      }
+      if (response === void 0) {
+        if (e instanceof Error) {
+          throw new FetchError(
+            e,
+            "The request failed and the interceptors did not return an alternative response"
+          );
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+};
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+  response;
+  name = "ResponseError";
+};
+var FetchError = class extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+  cause;
+  name = "FetchError";
+};
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+function mapValues(data, fn) {
+  return Object.keys(data).reduce(
+    (acc, key) => ({ ...acc, [key]: fn(data[key]) }),
+    {}
+  );
+}
+function CompanyCreditBalanceFromJSON(json) {
+  return CompanyCreditBalanceFromJSONTyped(json, false);
+}
+function CompanyCreditBalanceFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    remaining: json["remaining"],
+    reserved: json["reserved"],
+    settled: json["settled"]
+  };
+}
 var TrialStatus = {
   Active: "active",
   Converted: "converted",
@@ -753,6 +1065,7 @@ function CheckFlagsResponseDataFromJSONTyped(json, ignoreDiscriminator) {
     return json;
   }
   return {
+    creditBalances: json["credit_balances"] == null ? void 0 : mapValues(json["credit_balances"], CompanyCreditBalanceFromJSON),
     flags: json["flags"].map(CheckFlagResponseDataFromJSON),
     plan: json["plan"] == null ? void 0 : DatastreamCompanyPlanFromJSON(json["plan"])
   };
@@ -781,6 +1094,7 @@ function EventBodyFlagCheckToJSONTyped(value, ignoreDiscriminator = false) {
     error: value["error"],
     flag_id: value["flagId"],
     flag_key: value["flagKey"],
+    preflight: value["preflight"],
     reason: value["reason"],
     req_company: value["reqCompany"],
     req_user: value["reqUser"],
@@ -835,7 +1149,10 @@ var CheckFlagReturnFromJSON = (json) => {
   return {
     featureUsageExceeded,
     companyId: companyId == null ? void 0 : companyId,
+    creditId: entitlement?.creditId == null ? void 0 : entitlement.creditId,
     creditRemaining: entitlement?.creditRemaining == null ? void 0 : entitlement.creditRemaining,
+    creditReserved: entitlement?.creditReserved == null ? void 0 : entitlement.creditReserved,
+    creditSettled: entitlement?.creditSettled == null ? void 0 : entitlement.creditSettled,
     error: error == null ? void 0 : error,
     featureAllocation: resolvedAllocation == null ? void 0 : resolvedAllocation,
     featureUsage: resolvedUsage == null ? void 0 : resolvedUsage,
@@ -861,6 +1178,22 @@ var CheckPlanReturnFromJSON = (json) => {
     trialStatus: trialStatus == null ? void 0 : trialStatus
   };
 };
+var CreditBalancesFromJSON = (json) => {
+  if (json == null || typeof json !== "object") {
+    return {};
+  }
+  const balances = {};
+  for (const [creditId, raw] of Object.entries(json)) {
+    if (raw == null || typeof raw !== "object") continue;
+    const { remaining, reserved, settled } = CompanyCreditBalanceFromJSON(raw);
+    if (typeof remaining !== "number" || typeof reserved !== "number" || typeof settled !== "number") {
+      continue;
+    }
+    balances[creditId] = { remaining, reserved, settled };
+  }
+  return balances;
+};
+var cacheVersion = "bb56e75d";
 function contextString(context) {
   const sortedContext = Object.keys(context).reduce((acc, key) => {
     const sortedKeys = Object.keys(
@@ -875,143 +1208,688 @@ function contextString(context) {
   }, {});
   return JSON.stringify(sortedContext);
 }
-var version = "1.4.0";
-var anonymousIdKey = "schematicId";
-var Schematic = class {
-  additionalHeaders = {};
-  apiKey;
-  apiUrl = "https://api.schematichq.com";
-  conn = null;
-  context = {};
-  debugEnabled = false;
-  offlineEnabled = false;
-  eventQueue;
-  contextDependentEventQueue;
-  eventUrl = "https://c.schematichq.com";
-  flagCheckListeners = {};
-  flagValueListeners = {};
-  isPending = true;
-  isPendingListeners = /* @__PURE__ */ new Set();
-  planListeners = /* @__PURE__ */ new Set();
-  storage;
-  useWebSocket = false;
-  checks = {};
-  featureUsageEventMap = {};
-  planChecks = {};
-  webSocketUrl = "wss://api.schematichq.com";
-  webSocketConnectionTimeout = 1e4;
-  webSocketReconnect = true;
-  webSocketMaxReconnectAttempts = 7;
-  // Max attempts after connection disrupted
-  webSocketMaxConnectionAttempts = 3;
-  // Max attempts for initial connection
-  webSocketInitialRetryDelay = 1e3;
-  webSocketMaxRetryDelay = 3e4;
-  wsReconnectAttempts = 0;
-  wsReconnectTimer = null;
-  wsIntentionalDisconnect = false;
-  currentWebSocket = null;
-  isConnecting = false;
-  maxEventQueueSize = 100;
-  // Prevent memory issues with very long network outages
-  maxEventRetries = 5;
-  // Maximum retry attempts for failed events
-  eventRetryInitialDelay = 1e3;
-  // Initial retry delay in ms
-  eventRetryMaxDelay = 3e4;
-  // Maximum retry delay in ms
-  retryTimer = null;
-  flagValueDefaults = {};
-  flagCheckDefaults = {};
-  fallbackCheckCache = {};
-  constructor(apiKey, options) {
-    this.apiKey = apiKey;
-    this.eventQueue = [];
-    this.contextDependentEventQueue = [];
-    this.useWebSocket = options?.useWebSocket ?? false;
-    this.debugEnabled = options?.debug ?? false;
-    this.offlineEnabled = options?.offline ?? false;
-    if (typeof window !== "undefined" && typeof window.location !== "undefined") {
-      const params = new URLSearchParams(window.location.search);
-      const debugParam = params.get("schematic_debug");
-      if (debugParam !== null && (debugParam === "" || debugParam === "true" || debugParam === "1")) {
-        this.debugEnabled = true;
-      }
-      const offlineParam = params.get("schematic_offline");
-      if (offlineParam !== null && (offlineParam === "" || offlineParam === "true" || offlineParam === "1")) {
-        this.offlineEnabled = true;
-        this.debugEnabled = true;
-      }
-    }
-    if (this.offlineEnabled && options?.debug !== false) {
-      this.debugEnabled = true;
-    }
-    if (this.offlineEnabled) {
-      this.setIsPending(false);
-    }
-    this.additionalHeaders = {
-      "X-Schematic-Client-Version": `schematic-js@${version}`,
-      ...options?.additionalHeaders ?? {}
-    };
-    if (options?.storage) {
-      this.storage = options.storage;
-    } else {
-      try {
-        if (typeof localStorage !== "undefined") {
-          this.storage = localStorage;
-        }
-      } catch {
+var version = "1.7.0";
+var models_exports = {};
+__export2(models_exports, {
+  ApiErrorFromJSON: () => ApiErrorFromJSON,
+  ApiErrorFromJSONTyped: () => ApiErrorFromJSONTyped,
+  ApiErrorToJSON: () => ApiErrorToJSON,
+  ApiErrorToJSONTyped: () => ApiErrorToJSONTyped,
+  CompanyInvoiceResponseDataFromJSON: () => CompanyInvoiceResponseDataFromJSON,
+  CompanyInvoiceResponseDataFromJSONTyped: () => CompanyInvoiceResponseDataFromJSONTyped,
+  CompanyInvoiceResponseDataToJSON: () => CompanyInvoiceResponseDataToJSON,
+  CompanyInvoiceResponseDataToJSONTyped: () => CompanyInvoiceResponseDataToJSONTyped,
+  CompanyInvoicesResponseDataFromJSON: () => CompanyInvoicesResponseDataFromJSON,
+  CompanyInvoicesResponseDataFromJSONTyped: () => CompanyInvoicesResponseDataFromJSONTyped,
+  CompanyInvoicesResponseDataToJSON: () => CompanyInvoicesResponseDataToJSON,
+  CompanyInvoicesResponseDataToJSONTyped: () => CompanyInvoicesResponseDataToJSONTyped,
+  GetCompanyInvoicesParamsFromJSON: () => GetCompanyInvoicesParamsFromJSON,
+  GetCompanyInvoicesParamsFromJSONTyped: () => GetCompanyInvoicesParamsFromJSONTyped,
+  GetCompanyInvoicesParamsToJSON: () => GetCompanyInvoicesParamsToJSON,
+  GetCompanyInvoicesParamsToJSONTyped: () => GetCompanyInvoicesParamsToJSONTyped,
+  GetCompanyInvoicesResponseFromJSON: () => GetCompanyInvoicesResponseFromJSON,
+  GetCompanyInvoicesResponseFromJSONTyped: () => GetCompanyInvoicesResponseFromJSONTyped,
+  GetCompanyInvoicesResponseToJSON: () => GetCompanyInvoicesResponseToJSON,
+  GetCompanyInvoicesResponseToJSONTyped: () => GetCompanyInvoicesResponseToJSONTyped,
+  InvoiceStatus: () => InvoiceStatus,
+  InvoiceStatusFromJSON: () => InvoiceStatusFromJSON,
+  InvoiceStatusFromJSONTyped: () => InvoiceStatusFromJSONTyped,
+  InvoiceStatusToJSON: () => InvoiceStatusToJSON,
+  InvoiceStatusToJSONTyped: () => InvoiceStatusToJSONTyped,
+  instanceOfApiError: () => instanceOfApiError,
+  instanceOfCompanyInvoiceResponseData: () => instanceOfCompanyInvoiceResponseData,
+  instanceOfCompanyInvoicesResponseData: () => instanceOfCompanyInvoicesResponseData,
+  instanceOfGetCompanyInvoicesParams: () => instanceOfGetCompanyInvoicesParams,
+  instanceOfGetCompanyInvoicesResponse: () => instanceOfGetCompanyInvoicesResponse,
+  instanceOfInvoiceStatus: () => instanceOfInvoiceStatus
+});
+function instanceOfApiError(value) {
+  if (!("error" in value) || value["error"] === void 0) return false;
+  return true;
+}
+function ApiErrorFromJSON(json) {
+  return ApiErrorFromJSONTyped(json, false);
+}
+function ApiErrorFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    error: json["error"]
+  };
+}
+function ApiErrorToJSON(json) {
+  return ApiErrorToJSONTyped(json, false);
+}
+function ApiErrorToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    error: value["error"]
+  };
+}
+var InvoiceStatus = {
+  Draft: "draft",
+  Open: "open",
+  Paid: "paid",
+  Uncollectible: "uncollectible",
+  Void: "void"
+};
+function instanceOfInvoiceStatus(value) {
+  for (const key in InvoiceStatus) {
+    if (Object.prototype.hasOwnProperty.call(InvoiceStatus, key)) {
+      if (InvoiceStatus[key] === value) {
+        return true;
       }
     }
-    if (options?.apiUrl !== void 0) {
-      this.apiUrl = options.apiUrl;
-    }
-    if (options?.eventUrl !== void 0) {
-      this.eventUrl = options.eventUrl;
-    }
-    if (options?.webSocketUrl !== void 0) {
-      this.webSocketUrl = options.webSocketUrl;
-    }
-    if (options?.webSocketConnectionTimeout !== void 0) {
-      this.webSocketConnectionTimeout = options.webSocketConnectionTimeout;
-    }
-    if (options?.webSocketReconnect !== void 0) {
-      this.webSocketReconnect = options.webSocketReconnect;
-    }
-    if (options?.webSocketMaxReconnectAttempts !== void 0) {
-      this.webSocketMaxReconnectAttempts = options.webSocketMaxReconnectAttempts;
-    }
-    if (options?.webSocketInitialRetryDelay !== void 0) {
-      this.webSocketInitialRetryDelay = options.webSocketInitialRetryDelay;
-    }
-    if (options?.webSocketMaxRetryDelay !== void 0) {
-      this.webSocketMaxRetryDelay = options.webSocketMaxRetryDelay;
-    }
-    if (options?.maxEventQueueSize !== void 0) {
-      this.maxEventQueueSize = options.maxEventQueueSize;
-    }
-    if (options?.maxEventRetries !== void 0) {
-      this.maxEventRetries = options.maxEventRetries;
-    }
-    if (options?.eventRetryInitialDelay !== void 0) {
-      this.eventRetryInitialDelay = options.eventRetryInitialDelay;
-    }
-    if (options?.eventRetryMaxDelay !== void 0) {
-      this.eventRetryMaxDelay = options.eventRetryMaxDelay;
-    }
-    if (options?.flagValueDefaults !== void 0) {
-      this.flagValueDefaults = options.flagValueDefaults;
-    }
-    if (options?.flagCheckDefaults !== void 0) {
-      this.flagCheckDefaults = options.flagCheckDefaults;
-    }
-    if (typeof window !== "undefined" && window?.addEventListener) {
-      window.addEventListener("beforeunload", () => {
-        this.flushEventQueue();
-        this.flushContextDependentEventQueue();
-      });
-      if (this.useWebSocket) {
-        window.addEventListener("offline", () => {
+  }
+  return false;
+}
+function InvoiceStatusFromJSON(json) {
+  return InvoiceStatusFromJSONTyped(json, false);
+}
+function InvoiceStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function InvoiceStatusToJSON(value) {
+  return value;
+}
+function InvoiceStatusToJSONTyped(value, ignoreDiscriminator) {
+  return value;
+}
+function instanceOfCompanyInvoiceResponseData(value) {
+  if (!("amountDue" in value) || value["amountDue"] === void 0) return false;
+  if (!("createdAt" in value) || value["createdAt"] === void 0) return false;
+  if (!("currency" in value) || value["currency"] === void 0) return false;
+  if (!("id" in value) || value["id"] === void 0) return false;
+  return true;
+}
+function CompanyInvoiceResponseDataFromJSON(json) {
+  return CompanyInvoiceResponseDataFromJSONTyped(json, false);
+}
+function CompanyInvoiceResponseDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    amountDue: json["amount_due"],
+    createdAt: new Date(json["created_at"]),
+    currency: json["currency"],
+    dueDate: json["due_date"] == null ? void 0 : new Date(json["due_date"]),
+    id: json["id"],
+    status: json["status"] == null ? void 0 : InvoiceStatusFromJSON(json["status"]),
+    url: json["url"] == null ? void 0 : json["url"]
+  };
+}
+function CompanyInvoiceResponseDataToJSON(json) {
+  return CompanyInvoiceResponseDataToJSONTyped(json, false);
+}
+function CompanyInvoiceResponseDataToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    amount_due: value["amountDue"],
+    created_at: value["createdAt"].toISOString(),
+    currency: value["currency"],
+    due_date: value["dueDate"] == null ? void 0 : value["dueDate"].toISOString(),
+    id: value["id"],
+    status: InvoiceStatusToJSON(value["status"]),
+    url: value["url"]
+  };
+}
+function instanceOfCompanyInvoicesResponseData(value) {
+  if (!("count" in value) || value["count"] === void 0) return false;
+  if (!("invoices" in value) || value["invoices"] === void 0) return false;
+  return true;
+}
+function CompanyInvoicesResponseDataFromJSON(json) {
+  return CompanyInvoicesResponseDataFromJSONTyped(json, false);
+}
+function CompanyInvoicesResponseDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    count: json["count"],
+    invoices: json["invoices"].map(
+      CompanyInvoiceResponseDataFromJSON
+    )
+  };
+}
+function CompanyInvoicesResponseDataToJSON(json) {
+  return CompanyInvoicesResponseDataToJSONTyped(json, false);
+}
+function CompanyInvoicesResponseDataToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    count: value["count"],
+    invoices: value["invoices"].map(
+      CompanyInvoiceResponseDataToJSON
+    )
+  };
+}
+function instanceOfGetCompanyInvoicesParams(value) {
+  return true;
+}
+function GetCompanyInvoicesParamsFromJSON(json) {
+  return GetCompanyInvoicesParamsFromJSONTyped(json, false);
+}
+function GetCompanyInvoicesParamsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    includePending: json["include_pending"] == null ? void 0 : json["include_pending"],
+    limit: json["limit"] == null ? void 0 : json["limit"],
+    offset: json["offset"] == null ? void 0 : json["offset"]
+  };
+}
+function GetCompanyInvoicesParamsToJSON(json) {
+  return GetCompanyInvoicesParamsToJSONTyped(json, false);
+}
+function GetCompanyInvoicesParamsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    include_pending: value["includePending"],
+    limit: value["limit"],
+    offset: value["offset"]
+  };
+}
+function instanceOfGetCompanyInvoicesResponse(value) {
+  if (!("data" in value) || value["data"] === void 0) return false;
+  if (!("params" in value) || value["params"] === void 0) return false;
+  return true;
+}
+function GetCompanyInvoicesResponseFromJSON(json) {
+  return GetCompanyInvoicesResponseFromJSONTyped(json, false);
+}
+function GetCompanyInvoicesResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    data: CompanyInvoicesResponseDataFromJSON(json["data"]),
+    params: GetCompanyInvoicesParamsFromJSON(json["params"])
+  };
+}
+function GetCompanyInvoicesResponseToJSON(json) {
+  return GetCompanyInvoicesResponseToJSONTyped(json, false);
+}
+function GetCompanyInvoicesResponseToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    data: CompanyInvoicesResponseDataToJSON(value["data"]),
+    params: GetCompanyInvoicesParamsToJSON(value["params"])
+  };
+}
+var DEFAULT_INVOICE_QUERY = {};
+function normalizeInvoiceQuery(query) {
+  const { includePending, ...rest } = query;
+  return includePending === true ? { ...rest, includePending: true } : rest;
+}
+var SchematicApiError = class extends Error {
+  constructor(status, path, body) {
+    super(
+      typeof body === "object" && body !== null && "error" in body ? String(body.error) : `Request to ${path} failed with status ${status}`
+    );
+    this.status = status;
+    this.path = path;
+    this.body = body;
+    this.name = "SchematicApiError";
+  }
+  status;
+  path;
+  body;
+};
+var DEFAULT_API_URL = "https://api.schematichq.com";
+var TOKEN_CACHE_SIZE = 10;
+function sessionKey(session) {
+  return JSON.stringify([session.company, session.user ?? null]);
+}
+var SchematicSession = class {
+  _apiUrl;
+  _headers;
+  _fetch;
+  _session;
+  _tokens = /* @__PURE__ */ new Map();
+  _resolving = /* @__PURE__ */ new Map();
+  /**
+   * Bumped when the session's identity changes, and only then — the object
+   * itself is replaced on every render. Anything asking "is this still the
+   * session I started under?" counts generations rather than comparing.
+   */
+  _generation = 0;
+  _listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this._session = options.session;
+    this._apiUrl = (options.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
+    this._headers = options.additionalHeaders ?? {};
+    this._fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  get key() {
+    return this._session === null || this._session === void 0 ? void 0 : sessionKey(this._session);
+  }
+  get status() {
+    if (this._session === void 0) {
+      return "pending";
+    }
+    return this._session === null ? "ended" : "active";
+  }
+  /** Only a statement that changes which pair is read counts as a change. */
+  set(session) {
+    if (session === void 0) {
+      return;
+    }
+    const previous = this._session;
+    this._session = session;
+    if (session === null) {
+      if (previous === null) {
+        return;
+      }
+      this._tokens.clear();
+      this._resolving.clear();
+      this._generation += 1;
+      this._emit({ type: "ended" });
+      return;
+    }
+    if (previous !== null && previous !== void 0) {
+      if (previous.company === session.company && (previous.user ?? null) === (session.user ?? null)) {
+        return;
+      }
+      this._generation += 1;
+      this._emit({ type: "changed" });
+      return;
+    }
+    this._generation += 1;
+    this._emit({ type: "started" });
+  }
+  onChange(listener) {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  _emit(event) {
+    for (const listener of this._listeners) {
+      listener(event);
+    }
+  }
+  _cached(key) {
+    const cached = this._tokens.get(key);
+    if (cached === void 0) {
+      return void 0;
+    }
+    if (cached.expiresAt !== void 0 && cached.expiresAt.getTime() <= Date.now()) {
+      this._tokens.delete(key);
+      return void 0;
+    }
+    this._tokens.delete(key);
+    this._tokens.set(key, cached);
+    return cached;
+  }
+  _cache(key, resolved) {
+    this._tokens.delete(key);
+    this._tokens.set(key, resolved);
+    while (this._tokens.size > TOKEN_CACHE_SIZE) {
+      const oldest = this._tokens.keys().next();
+      if (oldest.done === true) {
+        break;
+      }
+      this._tokens.delete(oldest.value);
+    }
+  }
+  /**
+   * The credential for a session, minted if this one is not held. `force`
+   * retires what is held first: the caller is a request the API has just
+   * rejected.
+   */
+  resolveToken(session, force) {
+    const { token } = session;
+    if (typeof token === "string") {
+      return Promise.resolve(token);
+    }
+    const key = sessionKey(session);
+    if (!force) {
+      const cached = this._cached(key);
+      if (cached !== void 0) {
+        return Promise.resolve(cached.token);
+      }
+    } else {
+      this._tokens.delete(key);
+    }
+    const inflight = this._resolving.get(key);
+    if (inflight !== void 0 && inflight.sessionGeneration === this._generation && (!force || inflight.forced)) {
+      return inflight.promise;
+    }
+    const provider = token;
+    const sessionGeneration = this._generation;
+    const owns = () => this._resolving.get(key)?.promise === promise;
+    const promise = Promise.resolve().then(() => provider()).then((result) => {
+      const { resolved, stamped } = asResolvedToken(result, session);
+      if (owns() && (this._generation === sessionGeneration || stamped)) {
+        this._cache(key, resolved);
+      }
+      return resolved.token;
+    }).finally(() => {
+      if (owns()) {
+        this._resolving.delete(key);
+      }
+    });
+    this._resolving.set(key, { promise, forced: force, sessionGeneration });
+    return promise;
+  }
+  /**
+   * Sends a request under the active session's credential, refreshing once
+   * and retrying if the API rejects it. Rejects rather than answering when
+   * the session changes while the request is in flight: the rows would
+   * otherwise come back as the answer to a question asked for another pair.
+   */
+  async request(path, options = {}) {
+    const { method = "GET", body } = options;
+    const send = async (credential2) => this._fetch(`${this._apiUrl}${path}`, {
+      method,
+      headers: {
+        "Accept": "application/json",
+        ...body === void 0 ? {} : { "Content-Type": "application/json" },
+        ...this._headers,
+        "X-Schematic-Api-Key": credential2
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+    const session = this._session;
+    if (session === null) {
+      throw new Error("There is no session to read data for.");
+    }
+    if (session === void 0) {
+      throw new Error("A session is required to read data.");
+    }
+    const provider = session.token;
+    const generation = this._generation;
+    const stillOurs = async (response2) => {
+      if (this._generation === generation) {
+        return;
+      }
+      if (response2 !== void 0) {
+        await discardBody(response2);
+      }
+      throw new Error("The session changed while this request was in flight.");
+    };
+    const credential = await this.resolveToken(session, false);
+    if (this._generation !== generation) {
+      throw new Error("The session changed before this request was sent.");
+    }
+    let response = await send(credential);
+    await stillOurs(response);
+    if (response.status === 401 && typeof provider === "function" && this._generation === generation) {
+      const status = response.status;
+      const rejected = await readBody(response);
+      let retried = false;
+      const current = this._session;
+      if (this._generation === generation && current !== null && current !== void 0) {
+        const refreshed = await this.resolveToken(current, true);
+        if (this._generation === generation) {
+          response = await send(refreshed);
+          await stillOurs(response);
+          retried = true;
+        }
+      }
+      if (!retried) {
+        throw new SchematicApiError(status, path, rejected);
+      }
+    }
+    const parsed = await readBody(response);
+    await stillOurs();
+    if (!response.ok) {
+      throw new SchematicApiError(response.status, path, parsed);
+    }
+    return parsed;
+  }
+};
+function asResolvedToken(result, session) {
+  if (typeof result === "string") {
+    return { resolved: { token: result }, stamped: false };
+  }
+  const token = result?.token;
+  if (typeof token !== "string" || token === "") {
+    throw new Error("The access token provider did not return a token.");
+  }
+  if (result.company !== void 0 && result.company !== session.company || result.user !== void 0 && session.user !== void 0 && result.user !== session.user) {
+    throw new Error(
+      "The access token provider returned a token for a different session."
+    );
+  }
+  const stamped = result.company !== void 0 && (session.user === void 0 || result.user !== void 0);
+  return { resolved: { token, expiresAt: asDate(result.expiresAt) }, stamped };
+}
+function asDate(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+async function discardBody(response) {
+  try {
+    await response.body?.cancel();
+  } catch {
+  }
+}
+async function readBody(response) {
+  const text = await response.text();
+  if (text === "") {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+var INVOICE_PAGE_SIZE = 12;
+var INVOICE_MAX_PAGE_SIZE = 250;
+var SchematicBillingClient = class {
+  /**
+   * Public so a second client over the same surface can be constructed on
+   * this one rather than minting tokens of its own.
+   */
+  session;
+  constructor(options = {}) {
+    this.session = options instanceof SchematicSession ? options : new SchematicSession(options);
+  }
+  get sessionKey() {
+    return this.session.key;
+  }
+  get sessionStatus() {
+    return this.session.status;
+  }
+  setSession(session) {
+    this.session.set(session);
+  }
+  onSessionChange(listener) {
+    return this.session.onChange(listener);
+  }
+  fetchInvoices(params) {
+    const query = new URLSearchParams({
+      limit: String(Math.min(params.limit, INVOICE_MAX_PAGE_SIZE)),
+      offset: String(params.offset)
+    });
+    if (params.includePending !== void 0) {
+      query.set("include_pending", String(params.includePending));
+    }
+    const path = `/company/invoices?${query}`;
+    return this.session.request(path).then((body) => {
+      if (body === null || typeof body !== "object" || !("data" in body)) {
+        throw new Error(`Malformed response from ${path}`);
+      }
+      const data = body.data;
+      if (data == null || data.invoices == null) {
+        return { invoices: [], count: 0 };
+      }
+      const decoded = GetCompanyInvoicesResponseFromJSON(body).data;
+      return { invoices: decoded.invoices, count: decoded.count };
+    });
+  }
+};
+var anonymousIdKey = "schematicId";
+var flagStateCachePrefix = "schematicCache";
+var flagStateCacheMaxContexts = 10;
+var flagStateCacheDefaultMaxAgeMs = 7 * 24 * 60 * 60 * 1e3;
+var emptyCreditBalances = Object.freeze({});
+var Schematic = class {
+  _additionalHeaders = {};
+  apiKey;
+  _apiUrl = "https://api.schematichq.com";
+  conn = null;
+  context = {};
+  debugEnabled = false;
+  offlineEnabled = false;
+  eventQueue;
+  contextDependentEventQueue;
+  eventUrl = "https://c.schematichq.com";
+  flagCheckListeners = {};
+  flagValueListeners = {};
+  isPending = true;
+  isPendingListeners = /* @__PURE__ */ new Set();
+  planListeners = /* @__PURE__ */ new Set();
+  creditBalanceListeners = /* @__PURE__ */ new Set();
+  storage;
+  persistFlagState = true;
+  flagStateCacheKey;
+  flagStateCacheMaxAgeMs = flagStateCacheDefaultMaxAgeMs;
+  cachedFlagState = null;
+  useWebSocket = false;
+  checks = {};
+  featureUsageEventMap = {};
+  planChecks = {};
+  creditBalances = {};
+  webSocketUrl = "wss://api.schematichq.com";
+  webSocketConnectionTimeout = 1e4;
+  webSocketReconnect = true;
+  webSocketMaxReconnectAttempts = 7;
+  // Max attempts after connection disrupted
+  webSocketMaxConnectionAttempts = 3;
+  // Max attempts for initial connection
+  webSocketInitialRetryDelay = 1e3;
+  webSocketMaxRetryDelay = 3e4;
+  wsReconnectAttempts = 0;
+  wsReconnectTimer = null;
+  wsIntentionalDisconnect = false;
+  currentWebSocket = null;
+  isConnecting = false;
+  maxEventQueueSize = 100;
+  // Prevent memory issues with very long network outages
+  maxEventRetries = 5;
+  // Maximum retry attempts for failed events
+  eventRetryInitialDelay = 1e3;
+  // Initial retry delay in ms
+  eventRetryMaxDelay = 3e4;
+  // Maximum retry delay in ms
+  retryTimer = null;
+  flagValueDefaults = {};
+  flagCheckDefaults = {};
+  fallbackCheckCache = {};
+  constructor(apiKey, options) {
+    this.apiKey = apiKey;
+    this.flagStateCacheKey = `${flagStateCachePrefix}:${apiKey}`;
+    this.eventQueue = [];
+    this.contextDependentEventQueue = [];
+    this.useWebSocket = options?.useWebSocket ?? false;
+    this.debugEnabled = options?.debug ?? false;
+    this.offlineEnabled = options?.offline ?? false;
+    this.persistFlagState = options?.persistFlagState ?? true;
+    if (typeof options?.flagStateCacheMaxAgeMs === "number" && options.flagStateCacheMaxAgeMs > 0) {
+      this.flagStateCacheMaxAgeMs = options.flagStateCacheMaxAgeMs;
+    }
+    if (typeof window !== "undefined" && typeof window.location !== "undefined") {
+      const params = new URLSearchParams(window.location.search);
+      const debugParam = params.get("schematic_debug");
+      if (debugParam !== null && (debugParam === "" || debugParam === "true" || debugParam === "1")) {
+        this.debugEnabled = true;
+      }
+      const offlineParam = params.get("schematic_offline");
+      if (offlineParam !== null && (offlineParam === "" || offlineParam === "true" || offlineParam === "1")) {
+        this.offlineEnabled = true;
+        this.debugEnabled = true;
+      }
+    }
+    if (this.offlineEnabled && options?.debug !== false) {
+      this.debugEnabled = true;
+    }
+    if (this.offlineEnabled) {
+      this.setIsPending(false);
+    }
+    this._additionalHeaders = {
+      "X-Schematic-Client-Version": `schematic-js@${version}`,
+      ...options?.additionalHeaders ?? {}
+    };
+    if (options?.storage) {
+      this.storage = options.storage;
+    } else {
+      try {
+        if (typeof localStorage !== "undefined") {
+          this.storage = localStorage;
+        }
+      } catch {
+      }
+    }
+    this.hydrateFlagStateFromCache();
+    if (options?.apiUrl !== void 0) {
+      this._apiUrl = options.apiUrl;
+    }
+    if (options?.eventUrl !== void 0) {
+      this.eventUrl = options.eventUrl;
+    }
+    if (options?.webSocketUrl !== void 0) {
+      this.webSocketUrl = options.webSocketUrl;
+    }
+    if (options?.webSocketConnectionTimeout !== void 0) {
+      this.webSocketConnectionTimeout = options.webSocketConnectionTimeout;
+    }
+    if (options?.webSocketReconnect !== void 0) {
+      this.webSocketReconnect = options.webSocketReconnect;
+    }
+    if (options?.webSocketMaxReconnectAttempts !== void 0) {
+      this.webSocketMaxReconnectAttempts = options.webSocketMaxReconnectAttempts;
+    }
+    if (options?.webSocketInitialRetryDelay !== void 0) {
+      this.webSocketInitialRetryDelay = options.webSocketInitialRetryDelay;
+    }
+    if (options?.webSocketMaxRetryDelay !== void 0) {
+      this.webSocketMaxRetryDelay = options.webSocketMaxRetryDelay;
+    }
+    if (options?.maxEventQueueSize !== void 0) {
+      this.maxEventQueueSize = options.maxEventQueueSize;
+    }
+    if (options?.maxEventRetries !== void 0) {
+      this.maxEventRetries = options.maxEventRetries;
+    }
+    if (options?.eventRetryInitialDelay !== void 0) {
+      this.eventRetryInitialDelay = options.eventRetryInitialDelay;
+    }
+    if (options?.eventRetryMaxDelay !== void 0) {
+      this.eventRetryMaxDelay = options.eventRetryMaxDelay;
+    }
+    if (options?.flagValueDefaults !== void 0) {
+      this.flagValueDefaults = options.flagValueDefaults;
+    }
+    if (options?.flagCheckDefaults !== void 0) {
+      this.flagCheckDefaults = options.flagCheckDefaults;
+    }
+    if (typeof window !== "undefined" && window?.addEventListener) {
+      window.addEventListener("beforeunload", () => {
+        this.flushEventQueue();
+        this.flushContextDependentEventQueue();
+      });
+      if (this.useWebSocket) {
+        window.addEventListener("offline", () => {
           this.debug("Browser went offline, closing WebSocket connection");
           this.handleNetworkOffline();
         });
@@ -1029,6 +1907,12 @@ var Schematic = class {
       this.debug("Initialized with debug mode enabled");
     }
   }
+  get apiUrl() {
+    return this._apiUrl;
+  }
+  get additionalHeaders() {
+    return { ...this._additionalHeaders };
+  }
   /**
    * Resolve fallback value according to priority order:
    * 1. Callsite fallback value (if provided)
@@ -1114,11 +1998,11 @@ var Schematic = class {
       return resolvedFallbackResult.value;
     }
     if (!this.useWebSocket) {
-      const requestUrl = `${this.apiUrl}/flags/${key}/check`;
+      const requestUrl = `${this._apiUrl}/flags/${key}/check`;
       return fetch(requestUrl, {
         method: "POST",
         headers: {
-          ...this.additionalHeaders ?? {},
+          ...this._additionalHeaders ?? {},
           "Content-Type": "application/json;charset=UTF-8",
           "X-Schematic-Api-Key": this.apiKey
         },
@@ -1256,6 +2140,29 @@ var Schematic = class {
         });
         this.notifyPlanListeners(plan);
       }
+      if (message.credit_balances !== void 0 && message.credit_balances !== null) {
+        const contextStr = contextString(context);
+        const updates = CreditBalancesFromJSON(message.credit_balances);
+        const previous = this.creditBalances[contextStr] ?? {};
+        let changed = false;
+        const merged = { ...previous };
+        for (const [creditId, next] of Object.entries(updates)) {
+          const current = previous[creditId];
+          if (current === void 0 || current.remaining !== next.remaining || current.reserved !== next.reserved || current.settled !== next.settled) {
+            merged[creditId] = next;
+            changed = true;
+          }
+        }
+        if (changed) {
+          this.creditBalances[contextStr] = merged;
+          this.debug(
+            `WebSocket credit balance update received. Notifying listeners`,
+            { creditBalances: merged }
+          );
+          this.notifyCreditBalanceListeners(merged);
+        }
+      }
+      this.persistContextToCache(contextString(context));
       this.flushContextDependentEventQueue();
       this.setIsPending(false);
     };
@@ -1298,12 +2205,12 @@ var Schematic = class {
       this.debug(`checkFlags offline result: returning empty object`);
       return {};
     }
-    const requestUrl = `${this.apiUrl}/flags/check`;
+    const requestUrl = `${this._apiUrl}/flags/check`;
     const requestBody = JSON.stringify(context);
     return fetch(requestUrl, {
       method: "POST",
       headers: {
-        ...this.additionalHeaders ?? {},
+        ...this._additionalHeaders ?? {},
         "Content-Type": "application/json;charset=UTF-8",
         "X-Schematic-Api-Key": this.apiKey
       },
@@ -1363,7 +2270,32 @@ var Schematic = class {
       return;
     }
     try {
-      this.setIsPending(true);
+      const newContextStr = contextString(context);
+      const cacheHit = this.hasCachedValuesForContext(newContextStr);
+      if (cacheHit) {
+        this.debug(
+          `setContext: cache hit for context, pre-resolving from cached values`
+        );
+        this.context = context;
+        this.flushContextDependentEventQueue();
+        this.setIsPending(false);
+        const cachedChecks = this.checks[newContextStr] ?? {};
+        for (const [flagKey, check] of Object.entries(cachedChecks)) {
+          if (check === void 0) continue;
+          this.notifyFlagCheckListeners(flagKey, check);
+          this.notifyFlagValueListeners(flagKey, check.value);
+        }
+        const cachedPlan = this.planChecks[newContextStr];
+        if (cachedPlan !== void 0) {
+          this.notifyPlanListeners(cachedPlan);
+        }
+        const cachedCreditBalances = this.creditBalances[newContextStr];
+        if (cachedCreditBalances !== void 0) {
+          this.notifyCreditBalanceListeners(cachedCreditBalances);
+        }
+      } else {
+        this.setIsPending(true);
+      }
       if (!this.conn) {
         if (this.isConnecting) {
           this.debug(
@@ -1374,7 +2306,7 @@ var Schematic = class {
           }
           if (this.conn !== null) {
             const socket2 = await this.conn;
-            await this.wsSendMessage(socket2, context);
+            await this.wsSendMessage(socket2, context, cacheHit);
             return;
           }
         }
@@ -1390,7 +2322,7 @@ var Schematic = class {
           this.conn = this.wsConnect();
           const socket2 = await this.conn;
           this.isConnecting = false;
-          await this.wsSendMessage(socket2, context);
+          await this.wsSendMessage(socket2, context, cacheHit);
           return;
         } catch (error) {
           this.isConnecting = false;
@@ -1398,7 +2330,7 @@ var Schematic = class {
         }
       }
       const socket = await this.conn;
-      await this.wsSendMessage(socket, context);
+      await this.wsSendMessage(socket, context, cacheHit);
     } catch (error) {
       console.warn("Failed to establish WebSocket connection:", error);
       this.context = context;
@@ -1458,10 +2390,12 @@ var Schematic = class {
       `Optimistically updating feature usage for event: ${eventName}`,
       { quantity }
     );
+    let dirty = false;
     Object.entries(flagsForEvent).forEach(([flagKey, check]) => {
       if (check === void 0) return;
       const updatedCheck = { ...check };
       if (typeof updatedCheck.featureUsage === "number") {
+        dirty = true;
         updatedCheck.featureUsage += quantity;
         if (typeof updatedCheck.featureAllocation === "number") {
           const wasExceeded = updatedCheck.featureUsageExceeded === true;
@@ -1491,6 +2425,9 @@ var Schematic = class {
         this.notifyFlagValueListeners(flagKey, updatedCheck.value);
       }
     });
+    if (dirty) {
+      this.persistContextToCache(contextString(this.context));
+    }
   };
   /**
    * Event processing
@@ -1593,6 +2530,206 @@ var Schematic = class {
     this.storage.setItem(anonymousIdKey, generatedAnonymousId);
     return generatedAnonymousId;
   };
+  hasCachedValuesForContext = (contextStr) => {
+    const cachedChecks = this.checks[contextStr];
+    if (cachedChecks !== void 0 && Object.keys(cachedChecks).length > 0) {
+      return true;
+    }
+    if (this.planChecks[contextStr] !== void 0) {
+      return true;
+    }
+    const cachedCreditBalances = this.creditBalances[contextStr];
+    return cachedCreditBalances !== void 0 && Object.keys(cachedCreditBalances).length > 0;
+  };
+  readFlagStateCache = () => {
+    if (!this.persistFlagState || this.storage === void 0) {
+      return null;
+    }
+    let raw;
+    try {
+      raw = this.storage.getItem(this.flagStateCacheKey);
+    } catch (error) {
+      this.debug("Failed to read flag state cache:", error);
+      return null;
+    }
+    if (raw === null || raw === void 0) {
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    } catch (error) {
+      this.debug("Flag state cache is not valid JSON, ignoring:", error);
+      return null;
+    }
+    if (parsed === null || typeof parsed !== "object" || parsed.version !== cacheVersion || typeof parsed.contexts !== "object" || parsed.contexts === null) {
+      this.debug(
+        `Flag state cache invalid or version mismatch (expected ${cacheVersion}), ignoring`,
+        {
+          parsedType: typeof parsed,
+          version: parsed?.version
+        }
+      );
+      return null;
+    }
+    return parsed;
+  };
+  reviveCachedCheck = (raw) => {
+    if (raw === null || typeof raw !== "object") return null;
+    const obj = raw;
+    if (typeof obj.flag !== "string" || typeof obj.value !== "boolean" || typeof obj.reason !== "string") {
+      return null;
+    }
+    const revived = { ...obj };
+    if (typeof revived.featureUsageResetAt === "string") {
+      const d = new Date(revived.featureUsageResetAt);
+      revived.featureUsageResetAt = isNaN(d.getTime()) ? void 0 : d;
+    }
+    return revived;
+  };
+  reviveCachedPlan = (raw) => {
+    if (raw === null || typeof raw !== "object") return null;
+    const obj = raw;
+    if (typeof obj.id !== "string" || typeof obj.name !== "string") {
+      return null;
+    }
+    const revived = { ...obj };
+    if (typeof revived.trialEndDate === "string") {
+      const d = new Date(revived.trialEndDate);
+      revived.trialEndDate = isNaN(d.getTime()) ? void 0 : d;
+    }
+    return revived;
+  };
+  reviveCachedCreditBalances = (raw) => {
+    if (raw === null || typeof raw !== "object") return null;
+    const revived = {};
+    for (const [creditId, value] of Object.entries(
+      raw
+    )) {
+      if (value === null || typeof value !== "object") continue;
+      const obj = value;
+      if (typeof obj.remaining !== "number" || typeof obj.reserved !== "number" || typeof obj.settled !== "number") {
+        continue;
+      }
+      revived[creditId] = {
+        remaining: obj.remaining,
+        reserved: obj.reserved,
+        settled: obj.settled
+      };
+    }
+    return Object.keys(revived).length > 0 ? revived : null;
+  };
+  hydrateFlagStateFromCache = () => {
+    const parsed = this.readFlagStateCache();
+    if (parsed === null) return;
+    const cutoff = Date.now() - this.flagStateCacheMaxAgeMs;
+    const fresh = {};
+    let contextsLoaded = 0;
+    let contextsExpired = 0;
+    for (const [contextStr, entry] of Object.entries(parsed.contexts)) {
+      if (entry === null || typeof entry !== "object") continue;
+      if (typeof entry.updatedAt !== "number") continue;
+      if (entry.updatedAt < cutoff) {
+        contextsExpired += 1;
+        continue;
+      }
+      const revivedChecks = {};
+      if (entry.checks !== null && typeof entry.checks === "object") {
+        for (const [flagKey, rawCheck] of Object.entries(entry.checks)) {
+          const revived = this.reviveCachedCheck(rawCheck);
+          if (revived === null || revived.flag !== flagKey) continue;
+          revivedChecks[flagKey] = revived;
+          if (typeof revived.featureUsageEvent === "string") {
+            this.updateFeatureUsageEventMap(revived);
+          }
+        }
+        if (Object.keys(revivedChecks).length > 0) {
+          this.checks[contextStr] = revivedChecks;
+        }
+      }
+      let revivedPlan;
+      if (entry.plan !== void 0 && entry.plan !== null) {
+        const p = this.reviveCachedPlan(entry.plan);
+        if (p !== null) {
+          revivedPlan = p;
+          this.planChecks[contextStr] = p;
+        }
+      }
+      let revivedCreditBalances;
+      if (entry.creditBalances !== void 0 && entry.creditBalances !== null) {
+        const balances = this.reviveCachedCreditBalances(entry.creditBalances);
+        if (balances !== null) {
+          revivedCreditBalances = balances;
+          this.creditBalances[contextStr] = balances;
+        }
+      }
+      fresh[contextStr] = {
+        checks: revivedChecks,
+        plan: revivedPlan,
+        creditBalances: revivedCreditBalances,
+        updatedAt: entry.updatedAt
+      };
+      contextsLoaded += 1;
+    }
+    this.cachedFlagState = { version: cacheVersion, contexts: fresh };
+    this.debug(
+      `Hydrated flag state cache: ${contextsLoaded} loaded, ${contextsExpired} expired`
+    );
+  };
+  persistContextToCache = (contextStr) => {
+    const checksForContext = this.checks[contextStr];
+    const planForContext = this.planChecks[contextStr];
+    const creditBalancesForContext = this.creditBalances[contextStr];
+    if (checksForContext === void 0 && planForContext === void 0 && creditBalancesForContext === void 0) {
+      return;
+    }
+    if (this.cachedFlagState === null) {
+      this.cachedFlagState = (this.persistFlagState ? this.readFlagStateCache() : null) ?? {
+        version: cacheVersion,
+        contexts: {}
+      };
+    }
+    const cleanChecks = {};
+    if (checksForContext !== void 0) {
+      for (const [flagKey, check] of Object.entries(checksForContext)) {
+        if (check !== void 0) cleanChecks[flagKey] = check;
+      }
+    }
+    this.cachedFlagState.contexts[contextStr] = {
+      checks: cleanChecks,
+      plan: planForContext,
+      creditBalances: creditBalancesForContext,
+      updatedAt: Date.now()
+    };
+    const entries = Object.entries(this.cachedFlagState.contexts);
+    if (entries.length > flagStateCacheMaxContexts) {
+      entries.sort((a, b) => b[1].updatedAt - a[1].updatedAt);
+      const survivors = entries.slice(0, flagStateCacheMaxContexts);
+      const survivorKeys = new Set(survivors.map(([k]) => k));
+      for (const key of Object.keys(this.checks)) {
+        if (!survivorKeys.has(key)) delete this.checks[key];
+      }
+      for (const key of Object.keys(this.planChecks)) {
+        if (!survivorKeys.has(key)) delete this.planChecks[key];
+      }
+      for (const key of Object.keys(this.creditBalances)) {
+        if (!survivorKeys.has(key)) delete this.creditBalances[key];
+      }
+      this.cachedFlagState = {
+        version: cacheVersion,
+        contexts: Object.fromEntries(survivors)
+      };
+    }
+    if (!this.persistFlagState || this.storage === void 0) return;
+    try {
+      this.storage.setItem(
+        this.flagStateCacheKey,
+        JSON.stringify(this.cachedFlagState)
+      );
+    } catch (error) {
+      this.debug("Failed to write flag state cache:", error);
+    }
+  };
   handleEvent = (eventType, eventBody) => {
     const event = {
       api_key: this.apiKey,
@@ -1620,7 +2757,7 @@ var Schematic = class {
       const response = await fetch(captureUrl, {
         method: "POST",
         headers: {
-          ...this.additionalHeaders ?? {},
+          ...this._additionalHeaders ?? {},
           "Content-Type": "application/json;charset=UTF-8"
         },
         body: payload
@@ -1853,6 +2990,9 @@ var Schematic = class {
     if (this.conn !== null) {
       try {
         const socket = await this.conn;
+        if (this.currentWebSocket === socket) {
+          this.currentWebSocket = null;
+        }
         if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
           socket.close();
         }
@@ -2018,6 +3158,7 @@ var Schematic = class {
       this.debug(`Creating WebSocket connection ${connectionId} to ${wsUrl}`);
       let timeoutId = null;
       let isResolved = false;
+      let didOpen = false;
       timeoutId = setTimeout(() => {
         if (!isResolved) {
           isResolved = true;
@@ -2031,6 +3172,7 @@ var Schematic = class {
       webSocket.onopen = () => {
         if (isResolved) return;
         isResolved = true;
+        didOpen = true;
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
         }
@@ -2056,11 +3198,12 @@ var Schematic = class {
         }
         this.debug(`WebSocket connection ${connectionId} closed`);
         this.conn = null;
+        const wasCurrent = this.currentWebSocket === webSocket;
         if (this.currentWebSocket === webSocket) {
           this.currentWebSocket = null;
           this.isConnecting = false;
         }
-        if (!isResolved && !this.wsIntentionalDisconnect && this.webSocketReconnect) {
+        if (wasCurrent && didOpen && !this.wsIntentionalDisconnect && this.webSocketReconnect) {
           this.attemptReconnect();
         }
       };
@@ -2110,7 +3253,7 @@ var Schematic = class {
           }
         });
         this.currentWebSocket = socket;
-        const clientVersion = this.additionalHeaders["X-Schematic-Client-Version"] ?? `schematic-js@${version}`;
+        const clientVersion = this._additionalHeaders["X-Schematic-Client-Version"] ?? `schematic-js@${version}`;
         const messagePayload = {
           apiKey: this.apiKey,
           clientVersion,
@@ -2156,6 +3299,16 @@ var Schematic = class {
     const plan = this.planChecks[contextStr];
     return plan;
   };
+  /** Get the company's lease-aware credit balances for the current context, keyed by credit ID */
+  getCreditBalances = () => {
+    const contextStr = contextString(this.context);
+    return this.creditBalances[contextStr] ?? emptyCreditBalances;
+  };
+  /** Get the company's lease-aware balance for a single credit type in the current context */
+  getCreditBalance = (creditId) => {
+    const contextStr = contextString(this.context);
+    return this.creditBalances[contextStr]?.[creditId];
+  };
   // flag checks state
   getFlagCheck = (flagKey) => {
     const contextStr = contextString(this.context);
@@ -2215,6 +3368,13 @@ var Schematic = class {
       this.planListeners.delete(listener);
     };
   };
+  /** Register an event listener that will be notified with the company's credit balances (keyed by credit ID) whenever they change */
+  addCreditBalanceListener = (listener) => {
+    this.creditBalanceListeners.add(listener);
+    return () => {
+      this.creditBalanceListeners.delete(listener);
+    };
+  };
   notifyFlagCheckListeners = (flagKey, check) => {
     const listeners = this.flagCheckListeners?.[flagKey] ?? [];
     if (listeners.size > 0) {
@@ -2278,6 +3438,17 @@ var Schematic = class {
       });
     });
   };
+  notifyCreditBalanceListeners = (value) => {
+    const listeners = this.creditBalanceListeners ?? [];
+    if (listeners.size > 0) {
+      this.debug(`Notifying ${listeners.size} credit balance listeners`, {
+        value
+      });
+    }
+    listeners.forEach(
+      (listener) => notifyCreditBalanceListener(listener, value)
+    );
+  };
 };
 var notifyPendingListener = (listener, value) => {
   if (listener.length > 0) {
@@ -2307,25 +3478,862 @@ var notifyPlanListener = (listener, value) => {
     listener();
   }
 };
+var notifyCreditBalanceListener = (listener, value) => {
+  if (listener.length > 0) {
+    listener(value);
+  } else {
+    listener();
+  }
+};
 
 // src/context/schematic.tsx
-var import_react = __toESM(require("react"));
+var import_react5 = __toESM(require("react"));
+
+// src/billing/contract/index.ts
+function normalizeInvoiceQuery2(query) {
+  return normalizeInvoiceQuery(query).includePending === true ? { includePending: true } : {};
+}
+
+// src/billing/store.ts
+var Resource = class {
+  constructor(_fetcher, initial, _readiness = () => "ready") {
+    this._fetcher = _fetcher;
+    this._readiness = _readiness;
+    this._loaded = initial !== void 0;
+    this._snapshot = {
+      data: initial,
+      error: void 0,
+      isPending: initial === void 0
+    };
+  }
+  _fetcher;
+  _readiness;
+  _snapshot;
+  _listeners = /* @__PURE__ */ new Set();
+  _inflight;
+  _extending;
+  /** A refetch asked for mid-load; runs once that load lands. */
+  _queued;
+  _generation = 0;
+  _loaded = false;
+  get snapshot() {
+    return this._snapshot;
+  }
+  get subscriberCount() {
+    return this._listeners.size;
+  }
+  getSnapshot = () => this._snapshot;
+  subscribe = (listener) => {
+    this._listeners.add(listener);
+    if (!this._loaded && this._inflight === void 0 && this._snapshot.error === void 0) {
+      void this.load();
+    }
+    return () => {
+      this._listeners.delete(listener);
+    };
+  };
+  load() {
+    if (this._inflight !== void 0) {
+      return this._inflight;
+    }
+    const readiness = this._readiness();
+    if (readiness !== "ready") {
+      if (readiness === "never" && this._snapshot.isPending) {
+        this._set({ ...this._snapshot, isPending: false });
+      }
+      return Promise.resolve();
+    }
+    const generation = ++this._generation;
+    this._set({ ...this._snapshot, error: void 0, isPending: true });
+    const run = Promise.resolve().then(() => this._fetcher()).then(
+      (data) => {
+        if (generation !== this._generation) return;
+        this._loaded = true;
+        this._set({ data, error: void 0, isPending: false });
+      },
+      (cause) => {
+        if (generation !== this._generation) return;
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        this._set({ ...this._snapshot, error, isPending: false });
+      }
+    ).finally(() => {
+      if (generation === this._generation) {
+        this._inflight = void 0;
+      }
+    });
+    this._inflight = run;
+    return run;
+  }
+  /**
+   * Reloads; `data` holds its current value until the response lands. Asked
+   * for mid-load, it runs again after: that request was built before
+   * whatever prompted this one. Refetches queued on one load share the
+   * re-run; a reset, seed, or clear in the meantime supersedes it.
+   */
+  refetch() {
+    if (this._inflight === void 0) {
+      return this.load();
+    }
+    if (this._queued === void 0) {
+      const generation = this._generation;
+      const queued = this._inflight.then(() => {
+        if (this._queued === queued) {
+          this._queued = void 0;
+        }
+        if (generation !== this._generation) {
+          return;
+        }
+        return this.load();
+      });
+      this._queued = queued;
+    }
+    return this._queued;
+  }
+  /**
+   * Pages: `fetcher` receives the current data and returns what replaces it.
+   * Never rejects — a caller that wants the failure reads `snapshot.error`,
+   * and `data` keeps what was already fetched.
+   *
+   * A load already in flight wins: it is about to refresh the window this
+   * would have appended to.
+   */
+  extend(fetcher) {
+    const current = this._snapshot.data;
+    if (current === void 0) {
+      return Promise.resolve();
+    }
+    if (this._readiness() !== "ready") {
+      return Promise.resolve();
+    }
+    if (this._extending !== void 0) {
+      return this._extending;
+    }
+    if (this._inflight !== void 0) {
+      return this._inflight;
+    }
+    const generation = ++this._generation;
+    this._set({ ...this._snapshot, error: void 0, isPending: true });
+    const run = Promise.resolve().then(() => fetcher(current)).then(
+      (data) => {
+        if (generation !== this._generation) return;
+        this._set({ data, error: void 0, isPending: false });
+      },
+      (cause) => {
+        if (generation !== this._generation) return;
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        this._set({ ...this._snapshot, error, isPending: false });
+      }
+    ).finally(() => {
+      if (this._extending === run) {
+        this._extending = void 0;
+      }
+    });
+    this._extending = run;
+    return run;
+  }
+  seed(data) {
+    this._generation++;
+    this._inflight = void 0;
+    this._extending = void 0;
+    this._queued = void 0;
+    this._loaded = true;
+    this._set({ data, error: void 0, isPending: false });
+  }
+  update(fn) {
+    if (this._snapshot.data === void 0) return;
+    this._generation++;
+    this._inflight = void 0;
+    this._extending = void 0;
+    this._queued = void 0;
+    this._set({ ...this._snapshot, data: fn(this._snapshot.data) });
+  }
+  /**
+   * Forgets everything and stays empty — no data, no error, not pending.
+   * What a resource holds when there is no session to hold it for: a session
+   * ending is not a failure and must not surface as one.
+   */
+  clear() {
+    this._generation++;
+    this._inflight = void 0;
+    this._extending = void 0;
+    this._queued = void 0;
+    this._loaded = false;
+    this._set({ data: void 0, error: void 0, isPending: false });
+  }
+  /** Forgets everything; reloads immediately if anyone is subscribed. */
+  reset() {
+    this._generation++;
+    this._inflight = void 0;
+    this._extending = void 0;
+    this._queued = void 0;
+    this._loaded = false;
+    const readiness = this._readiness();
+    const willLoad = this._listeners.size > 0 && readiness === "ready";
+    this._set({
+      data: void 0,
+      error: void 0,
+      isPending: willLoad || readiness === "waiting"
+    });
+    if (willLoad) {
+      void this.load();
+    }
+  }
+  _set(next) {
+    this._snapshot = next;
+    for (const listener of this._listeners) {
+      listener();
+    }
+  }
+};
+function hashKey(params) {
+  return JSON.stringify(canonical(params));
+}
+function canonical(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonical);
+  }
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isNaN(time) ? "Invalid Date" : value.toISOString();
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const v = value[key];
+      if (v !== void 0) {
+        out[key] = canonical(v);
+      }
+    }
+    return out;
+  }
+  return value ?? null;
+}
+var DEFAULT_EVICTION = { maxIdle: 4 };
+var KeyedResource = class {
+  constructor(_fetcher, options = {}) {
+    this._fetcher = _fetcher;
+    this._readiness = options.readiness ?? (() => "ready");
+    this._hash = options.hash ?? hashKey;
+    this._eviction = {
+      maxIdle: options.eviction?.maxIdle ?? DEFAULT_EVICTION.maxIdle
+    };
+  }
+  _fetcher;
+  _entries = /* @__PURE__ */ new Map();
+  _hash;
+  _eviction;
+  _readiness;
+  hash(params) {
+    return this._hash(params);
+  }
+  get size() {
+    return this._entries.size;
+  }
+  entries() {
+    return Array.from(this._entries, ([key, e]) => ({ key, ...e }));
+  }
+  get(params) {
+    const key = this._hash(params);
+    const existing = this._entries.get(key);
+    if (existing !== void 0) {
+      this._entries.delete(key);
+      this._entries.set(key, existing);
+      return existing.resource;
+    }
+    const resource = new Resource(
+      () => this._fetcher(params, resource.snapshot.data),
+      void 0,
+      this._readiness
+    );
+    this._entries.set(key, { params, resource });
+    return resource;
+  }
+  has(params) {
+    return this._entries.has(this._hash(params));
+  }
+  subscribe(params, listener) {
+    const resource = this.get(params);
+    const unsubscribe = resource.subscribe(listener);
+    return () => {
+      unsubscribe();
+      this._evict();
+    };
+  }
+  seed(params, data) {
+    this.get(params).seed(data);
+  }
+  evict(params) {
+    return this._entries.delete(this._hash(params));
+  }
+  resetAll() {
+    for (const [key, { resource }] of Array.from(this._entries)) {
+      if (resource.subscriberCount === 0) {
+        this._entries.delete(key);
+      } else {
+        resource.reset();
+      }
+    }
+  }
+  resumeAll() {
+    for (const { resource } of this._entries.values()) {
+      if (resource.subscriberCount === 0) {
+        continue;
+      }
+      const { data, error } = resource.snapshot;
+      if (data === void 0 || error !== void 0) {
+        void resource.load();
+      }
+    }
+  }
+  clearAll() {
+    for (const [key, { resource }] of Array.from(this._entries)) {
+      if (resource.subscriberCount === 0) {
+        this._entries.delete(key);
+      } else {
+        resource.clear();
+      }
+    }
+  }
+  invalidateAll() {
+    for (const { resource } of this._entries.values()) {
+      if (resource.snapshot.data !== void 0) {
+        void resource.refetch();
+      }
+    }
+  }
+  _evict() {
+    const idle = Array.from(this._entries).filter(
+      ([, e]) => e.resource.subscriberCount === 0
+    );
+    let excess = idle.length - this._eviction.maxIdle;
+    for (const [key] of idle) {
+      if (excess <= 0) break;
+      this._entries.delete(key);
+      excess -= 1;
+    }
+  }
+};
+
+// src/billing/client.ts
+function claimOf(client) {
+  return { status: client.sessionStatus, key: client.sessionKey };
+}
+function claimFrom(session) {
+  if (session === void 0) {
+    return void 0;
+  }
+  return session === null ? { status: "ended", key: void 0 } : { status: "active", key: sessionKey(session) };
+}
+function judgeSeed(seedKey, claim) {
+  if (claim.status === "ended") {
+    return "drop";
+  }
+  if (seedKey === void 0) {
+    return "adopt";
+  }
+  if (claim.status === "pending") {
+    return "hold";
+  }
+  return seedKey === claim.key ? "adopt" : "drop";
+}
+var READINESS = {
+  pending: "waiting",
+  active: "ready",
+  ended: "never"
+};
+var BillingStore = class {
+  constructor(_client, initialData = {}, options = {}) {
+    this._client = _client;
+    this._pageSize = options.pageSize ?? INVOICE_PAGE_SIZE;
+    this.invoices = new KeyedResource(
+      (query, current) => this._reloadWindow(
+        query,
+        Math.max(this._pageSize, current?.invoices.length ?? 0)
+      ),
+      // Waiting until connected; then a session still pending stays
+      // pending, and one that has ended settles empty rather than recording
+      // the client's refusal as an error.
+      {
+        readiness: () => this._connected ? READINESS[this._client.sessionStatus] : "waiting"
+      }
+    );
+    if (initialData.invoices !== void 0) {
+      this._held = {
+        // Normalized the way the hook normalizes, or the caller asking for
+        // it fetches the same page again.
+        params: normalizeInvoiceQuery2(
+          initialData.params?.invoices ?? DEFAULT_INVOICE_QUERY
+        ),
+        data: initialData.invoices,
+        key: initialData.sessionKey
+      };
+      this._settleSeed(claimFrom(options.session) ?? claimOf(this._client));
+    }
+  }
+  _client;
+  invoices;
+  _pageSize;
+  _unsubscribe;
+  _connected = false;
+  _seeded = false;
+  /** The session that prefetch was for, where it said. */
+  _seedKey;
+  /** A stamped prefetch waiting for a session to check it against. */
+  _held;
+  /**
+   * Not done in the constructor: the provider arms it from an effect, and
+   * React runs an effect, its cleanup, then the effect again under
+   * StrictMode. A subscription made once at construction is torn down by
+   * that cleanup and never comes back, leaving the store deaf to every
+   * session change for the rest of the page.
+   *
+   * Also what opens the store: subscribers who arrived first have been
+   * waiting, and this is the moment the session is known to be installed.
+   */
+  connect() {
+    this._unsubscribe?.();
+    const unsubscribe = this._client.onSessionChange?.((event) => {
+      if (event.type === "ended") {
+        this._held = void 0;
+        this._seeded = false;
+        this.clearAll();
+      } else if (event.type === "changed") {
+        this._held = void 0;
+        this._seeded = false;
+        this.resetAll();
+      } else {
+        this._onStarted();
+      }
+    });
+    this._unsubscribe = unsubscribe;
+    if (!this._connected) {
+      this._connected = true;
+      this._settleSeed(claimOf(this._client));
+      this.resumeAll();
+    }
+    return () => {
+      unsubscribe?.();
+      if (this._unsubscribe === unsubscribe) {
+        this._unsubscribe = void 0;
+      }
+    };
+  }
+  _onStarted() {
+    const claim = claimOf(this._client);
+    this._settleSeed(claim);
+    if (this._seeded && judgeSeed(this._seedKey, claim) !== "adopt") {
+      this._seeded = false;
+      this.resetAll();
+      return;
+    }
+    this._seeded = false;
+    this.resumeAll();
+  }
+  /** Adopts, keeps holding, or drops the prefetch, by what `claim` says. */
+  _settleSeed(claim) {
+    const held = this._held;
+    if (held === void 0) {
+      return;
+    }
+    const verdict = judgeSeed(held.key, claim);
+    if (verdict === "hold") {
+      return;
+    }
+    this._held = void 0;
+    if (verdict === "adopt") {
+      this.invoices.seed(held.params, held.data);
+      this._seedKey = held.key;
+      this._seeded = true;
+    }
+  }
+  resource(name) {
+    return this[name];
+  }
+  /** Forgets every resource; subscribed ones reload, idle ones are dropped. */
+  resetAll() {
+    for (const name of RESOURCE_NAMES) {
+      this[name].resetAll();
+    }
+  }
+  /** Forgets every resource and leaves them empty; nothing reloads. */
+  clearAll() {
+    for (const name of RESOURCE_NAMES) {
+      this[name].clearAll();
+    }
+  }
+  /** Loads every resource that is subscribed and has nothing yet. */
+  resumeAll() {
+    for (const name of RESOURCE_NAMES) {
+      this[name].resumeAll();
+    }
+  }
+  /** Reloads every resource that has been loaded, keeping its current data. */
+  invalidateAll() {
+    for (const name of RESOURCE_NAMES) {
+      this[name].invalidateAll();
+    }
+  }
+  /**
+   * Appends the next page to the invoices list for `query`, when there is
+   * one. A failure records the error on the resource and keeps the rows
+   * already fetched; the returned promise never rejects.
+   */
+  loadMoreInvoices(query = DEFAULT_INVOICE_QUERY) {
+    const resource = this.invoices.get(normalizeInvoiceQuery2(query));
+    if (resource.snapshot.data?.hasMore !== true) {
+      return Promise.resolve();
+    }
+    return resource.extend(async (current) => {
+      const page = await this._fetchInvoices(
+        normalizeInvoiceQuery2(query),
+        current.invoices.length,
+        this._pageSize
+      );
+      const invoices = [...current.invoices, ...page.invoices];
+      return {
+        invoices,
+        count: page.count,
+        // From the count the page came back with, not the one the list was
+        // built on: an invoice finalized between the two requests changes
+        // what is left to load. An empty page ends the list whatever the
+        // count says — the rows and the count are two queries, and a count
+        // that outruns the rows would otherwise leave `hasMore` true for
+        // good, with every further page fetching nothing.
+        hasMore: page.invoices.length > 0 && invoices.length < page.count
+      };
+    });
+  }
+  dispose() {
+    this._unsubscribe?.();
+  }
+  /**
+   * Re-reads the window already loaded, in as many requests as the API's
+   * page cap needs. A window paged past that cap still comes back whole:
+   * asking for it in one request would be a 400, and asking for only the
+   * first page would drop the rest.
+   */
+  async _reloadWindow(query, window2) {
+    const invoices = [];
+    let count = 0;
+    while (invoices.length < window2) {
+      const page = await this._fetchInvoices(
+        query,
+        invoices.length,
+        Math.min(INVOICE_MAX_PAGE_SIZE, window2 - invoices.length)
+      );
+      count = page.count;
+      invoices.push(...page.invoices);
+      if (page.invoices.length === 0 || invoices.length >= count) {
+        break;
+      }
+    }
+    return {
+      invoices,
+      count,
+      hasMore: invoices.length > 0 && invoices.length < count
+    };
+  }
+  /**
+   * Returns what the server said and nothing more: whether there is more to
+   * load depends on the whole window, which only the caller assembling it
+   * knows — `_reloadWindow` across its requests, and `loadMoreInvoices`
+   * across the rows already loaded.
+   */
+  _fetchInvoices(query, offset, limit) {
+    return this._client.fetchInvoices({ ...query, limit, offset });
+  }
+};
+var RESOURCE_NAMES = ["invoices"];
+
+// src/billing/context.tsx
+var import_react2 = require("react");
+
+// src/i18n/context.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var EMPTY = Object.freeze({});
+var SchematicI18nContext = (0, import_react.createContext)(EMPTY);
+function SchematicI18nProvider({
+  children,
+  locale,
+  onMissingString,
+  strings,
+  translate
+}) {
+  const parent = (0, import_react.useContext)(SchematicI18nContext);
+  const value = (0, import_react.useMemo)(
+    () => ({
+      locale: locale ?? parent.locale,
+      translate: translate ?? parent.translate,
+      strings: strings === void 0 ? parent.strings : { ...parent.strings, ...strings },
+      onMissingString: onMissingString ?? parent.onMissingString
+    }),
+    [locale, onMissingString, parent, strings, translate]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SchematicI18nContext.Provider, { value, children });
+}
+function useSchematicI18n() {
+  return (0, import_react.useContext)(SchematicI18nContext);
+}
+function useSchematicLocale() {
+  return (0, import_react.useContext)(SchematicI18nContext).locale;
+}
+function useSchematicTranslate() {
+  return (0, import_react.useContext)(SchematicI18nContext).translate;
+}
+function useSchematicStrings() {
+  return (0, import_react.useContext)(SchematicI18nContext).strings;
+}
+
+// src/billing/context.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var BillingDataContext = (0, import_react2.createContext)(
+  void 0
+);
+var MISSING_BILLING_SOURCE_MESSAGE = "Schematic billing hooks need a SchematicProvider with a session, billingClient, or initialData, or a BillingDataProvider.";
+var missingSourceError = new Error(MISSING_BILLING_SOURCE_MESSAGE);
+var missingHandle = {
+  data: void 0,
+  error: missingSourceError,
+  isPending: false,
+  refetch: () => {
+  }
+};
+var missingBillingSource = {
+  subscribe: () => () => {
+  },
+  handle: () => missingHandle,
+  loadMoreInvoices: () => Promise.resolve(),
+  invalidateAll: () => {
+  }
+};
+function useBillingDataSource() {
+  return (0, import_react2.useContext)(BillingDataContext) ?? missingBillingSource;
+}
+function BillingDataProvider({
+  children,
+  data,
+  locale,
+  onLoadMoreInvoices,
+  onMissingString,
+  onRefetch,
+  status,
+  strings,
+  translate
+}) {
+  const source = (0, import_react2.useMemo)(() => {
+    const handles = /* @__PURE__ */ new Map();
+    return {
+      subscribe: () => () => {
+      },
+      handle: (name) => {
+        const cached = handles.get(name);
+        if (cached !== void 0) {
+          return cached;
+        }
+        const value = data[name];
+        const override = status?.[name];
+        const handle = {
+          data: value,
+          error: override?.error,
+          isPending: override?.isPending ?? value === void 0,
+          refetch: () => onRefetch?.(name)
+        };
+        handles.set(name, handle);
+        return handle;
+      },
+      loadMoreInvoices: (query) => {
+        onLoadMoreInvoices?.(query);
+        return Promise.resolve();
+      },
+      invalidateAll: () => {
+      }
+    };
+  }, [data, onLoadMoreInvoices, onRefetch, status]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(BillingDataContext.Provider, { value: source, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    SchematicI18nProvider,
+    {
+      locale,
+      strings,
+      translate,
+      onMissingString,
+      children
+    }
+  ) });
+}
+
+// src/billing/hooks.ts
+var import_react3 = require("react");
+function useStableParams(params) {
+  const key = hashKey(params);
+  const ref = (0, import_react3.useRef)({ key, params });
+  if (ref.current.key !== key) {
+    ref.current = { key, params };
+  }
+  return ref.current.params;
+}
+function useBillingResource(name, params) {
+  const source = useBillingDataSource();
+  const subscribe = (0, import_react3.useCallback)(
+    (listener) => source.subscribe(name, params, listener),
+    [name, params, source]
+  );
+  const getSnapshot = (0, import_react3.useCallback)(
+    () => source.handle(name, params),
+    [name, params, source]
+  );
+  return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+}
+function useInvoices(query = DEFAULT_INVOICE_QUERY) {
+  const source = useBillingDataSource();
+  const params = useStableParams(normalizeInvoiceQuery2(query));
+  const handle = useBillingResource("invoices", params);
+  const loadMore = (0, import_react3.useCallback)(
+    () => source.loadMoreInvoices(params),
+    [params, source]
+  );
+  return (0, import_react3.useMemo)(() => ({ ...handle, loadMore }), [handle, loadMore]);
+}
+function useInvalidateBillingData() {
+  return useBillingDataSource().invalidateAll;
+}
+
+// src/billing/provider.tsx
+var import_react4 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var SESSION_REPLACED_MESSAGE = "BillingProvider is moving its billingClient from one session to another. A client holds one session: if another provider shares this client, each will keep installing its own and show the other's data. Give each provider its own client.";
+function BillingProvider({
+  billingClient,
+  children,
+  initialData,
+  locale,
+  onMissingString,
+  session,
+  strings,
+  translate
+}) {
+  const initialRef = (0, import_react4.useRef)(initialData);
+  const install = () => {
+    billingClient?.setSession?.(session);
+  };
+  (0, import_react4.useEffect)(() => {
+    const claim = billingClient?.sessionKey;
+    if (claim !== void 0 && session !== null && session !== void 0 && claim !== sessionKey(session)) {
+      console.warn(SESSION_REPLACED_MESSAGE);
+    }
+  }, []);
+  (0, import_react4.useEffect)(install);
+  const seedSpent = (0, import_react4.useRef)(false);
+  const store = (0, import_react4.useMemo)(
+    () => billingClient === void 0 ? void 0 : new BillingStore(
+      billingClient,
+      seedSpent.current ? void 0 : initialRef.current,
+      {
+        // What `install` is about to say, so a stamped prefetch is
+        // judged now rather than after the effect.
+        session
+      }
+    ),
+    // `session` is read only when the store is built: the client learns
+    // later sessions through `install`, and the store through the client.
+    [billingClient]
+  );
+  (0, import_react4.useEffect)(() => {
+    if (store !== void 0) {
+      seedSpent.current = true;
+    }
+  }, [store]);
+  (0, import_react4.useEffect)(() => store?.connect(), [store]);
+  const source = (0, import_react4.useMemo)(() => {
+    if (store === void 0) {
+      return initialRef.current === void 0 ? void 0 : staticSource(initialRef.current);
+    }
+    const handles = /* @__PURE__ */ new WeakMap();
+    const handle = (name, params) => {
+      const resource = store.resource(name).get(params);
+      const snapshot = resource.getSnapshot();
+      const cached = handles.get(resource);
+      if (cached !== void 0 && cached.snapshot === snapshot) {
+        return cached.handle;
+      }
+      const next = {
+        ...snapshot,
+        refetch: () => void resource.refetch()
+      };
+      handles.set(resource, { snapshot, handle: next });
+      return next;
+    };
+    return {
+      subscribe: (name, params, listener) => store.resource(name).subscribe(params, listener),
+      handle,
+      loadMoreInvoices: (query) => store.loadMoreInvoices(query),
+      invalidateAll: () => store.invalidateAll()
+    };
+  }, [store]);
+  const localized = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    SchematicI18nProvider,
+    {
+      locale,
+      strings,
+      translate,
+      onMissingString,
+      children
+    }
+  );
+  if (source === void 0) {
+    return localized;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(BillingDataContext.Provider, { value: source, children: localized });
+}
+function staticSource(data) {
+  const handles = /* @__PURE__ */ new Map();
+  return {
+    subscribe: () => () => {
+    },
+    handle: (name) => {
+      const cached = handles.get(name);
+      if (cached !== void 0) {
+        return cached;
+      }
+      const value = data[name];
+      const next = {
+        data: value,
+        error: void 0,
+        isPending: value === void 0,
+        refetch: () => {
+        }
+      };
+      handles.set(name, next);
+      return next;
+    },
+    loadMoreInvoices: () => Promise.resolve(),
+    invalidateAll: () => {
+    }
+  };
+}
 
 // src/version.ts
-var version2 = "1.4.1";
+var version2 = "1.6.0";
 
 // src/context/schematic.tsx
-var import_jsx_runtime = require("react/jsx-runtime");
-var SchematicContext = (0, import_react.createContext)(
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var SchematicContext = (0, import_react5.createContext)(
   null
 );
 var SchematicProvider = ({
+  session,
+  billingClient,
   children,
   client: providedClient,
+  initialData,
+  locale,
+  onMissingString,
   publishableKey,
+  strings,
+  translate,
   ...clientOpts
 }) => {
-  const initialOptsRef = (0, import_react.useRef)({
+  const initialOptsRef = (0, import_react5.useRef)({
     publishableKey,
     useWebSocket: true,
     additionalHeaders: {
@@ -2333,7 +4341,7 @@ var SchematicProvider = ({
     },
     ...clientOpts
   });
-  const client = (0, import_react.useMemo)(() => {
+  const client = (0, import_react5.useMemo)(() => {
     if (providedClient) {
       return providedClient;
     }
@@ -2341,7 +4349,7 @@ var SchematicProvider = ({
       ...initialOptsRef.current
     });
   }, [providedClient]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     return () => {
       if (!providedClient) {
         client.cleanup().catch((error) => {
@@ -2350,16 +4358,46 @@ var SchematicProvider = ({
       }
     };
   }, [client, providedClient]);
-  const contextValue = (0, import_react.useMemo)(
+  const contextValue = (0, import_react5.useMemo)(
     () => ({
       client
     }),
     [client]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SchematicContext.Provider, { value: contextValue, children });
+  const { apiUrl, additionalHeaders } = initialOptsRef.current;
+  const providedApiUrl = providedClient?.apiUrl;
+  const resolvedBillingClient = (0, import_react5.useMemo)(
+    () => billingClient ?? new SchematicBillingClient({
+      session,
+      apiUrl: apiUrl ?? providedApiUrl,
+      // Read as they stand when a client is built: headers do not change
+      // where the token goes, so they are no reason to build one.
+      additionalHeaders: {
+        ...providedClient?.additionalHeaders,
+        ...additionalHeaders
+      }
+    }),
+    // `session` is deliberately absent: `BillingProvider` forwards it through
+    // `setSession`, so a token change resets the billing resources without
+    // rebuilding the client.
+    [additionalHeaders, apiUrl, billingClient, providedApiUrl]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(SchematicContext.Provider, { value: contextValue, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    BillingProvider,
+    {
+      billingClient: resolvedBillingClient,
+      initialData,
+      locale,
+      session,
+      strings,
+      translate,
+      onMissingString,
+      children
+    }
+  ) });
 };
 var useSchematic = () => {
-  const context = import_react.default.useContext(SchematicContext);
+  const context = import_react5.default.useContext(SchematicContext);
   if (context === null) {
     throw new Error("useSchematic must be used within a SchematicProvider");
   }
@@ -2367,11 +4405,11 @@ var useSchematic = () => {
 };
 
 // src/hooks/schematic.ts
-var import_react2 = require("react");
+var import_react6 = require("react");
 var useSchematicClient = (opts) => {
   const schematic = useSchematic();
   const { client } = opts ?? {};
-  return (0, import_react2.useMemo)(() => {
+  return (0, import_react6.useMemo)(() => {
     if (client) {
       return client;
     }
@@ -2380,7 +4418,7 @@ var useSchematicClient = (opts) => {
 };
 var useSchematicContext = (opts) => {
   const client = useSchematicClient(opts);
-  return (0, import_react2.useMemo)(
+  return (0, import_react6.useMemo)(
     () => ({
       setContext: client.setContext.bind(client)
     }),
@@ -2389,33 +4427,33 @@ var useSchematicContext = (opts) => {
 };
 var useSchematicEvents = (opts) => {
   const client = useSchematicClient(opts);
-  const track = (0, import_react2.useCallback)(
+  const track = (0, import_react6.useCallback)(
     (...args) => client.track(...args),
     [client]
   );
-  const identify = (0, import_react2.useCallback)(
+  const identify = (0, import_react6.useCallback)(
     (...args) => client.identify(...args),
     [client]
   );
-  return (0, import_react2.useMemo)(() => ({ track, identify }), [track, identify]);
+  return (0, import_react6.useMemo)(() => ({ track, identify }), [track, identify]);
 };
 var useSchematicFlag = (key, opts) => {
   const client = useSchematicClient(opts);
   const fallback = opts?.fallback ?? false;
-  const subscribe = (0, import_react2.useCallback)(
+  const subscribe = (0, import_react6.useCallback)(
     (callback) => client.addFlagValueListener(key, callback),
     [client, key]
   );
-  const getSnapshot = (0, import_react2.useCallback)(() => {
+  const getSnapshot = (0, import_react6.useCallback)(() => {
     const value = client.getFlagValue(key);
     return typeof value === "undefined" ? fallback : value;
   }, [client, key, fallback]);
-  return (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, () => fallback);
+  return (0, import_react6.useSyncExternalStore)(subscribe, getSnapshot, () => fallback);
 };
 var useSchematicEntitlement = (key, opts) => {
   const client = useSchematicClient(opts);
   const fallback = opts?.fallback ?? false;
-  const fallbackCheck = (0, import_react2.useMemo)(
+  const fallbackCheck = (0, import_react6.useMemo)(
     () => ({
       flag: key,
       reason: "Fallback",
@@ -2423,20 +4461,20 @@ var useSchematicEntitlement = (key, opts) => {
     }),
     [key, fallback]
   );
-  const subscribe = (0, import_react2.useCallback)(
+  const subscribe = (0, import_react6.useCallback)(
     (callback) => client.addFlagCheckListener(key, callback),
     [client, key]
   );
-  const getSnapshot = (0, import_react2.useCallback)(() => {
+  const getSnapshot = (0, import_react6.useCallback)(() => {
     const check = client.getFlagCheck(key);
     return check ?? fallbackCheck;
   }, [client, key, fallbackCheck]);
-  return (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, () => fallbackCheck);
+  return (0, import_react6.useSyncExternalStore)(subscribe, getSnapshot, () => fallbackCheck);
 };
 var useSchematicPlan = (opts) => {
   const client = useSchematicClient(opts);
   const fallback = opts?.fallback;
-  const fallbackPlan = (0, import_react2.useMemo)(
+  const fallbackPlan = (0, import_react6.useMemo)(
     () => fallback,
     [
       fallback?.id,
@@ -2445,24 +4483,52 @@ var useSchematicPlan = (opts) => {
       fallback?.trialStatus
     ]
   );
-  const subscribe = (0, import_react2.useCallback)(
+  const subscribe = (0, import_react6.useCallback)(
     (callback) => client.addPlanListener(callback),
     [client]
   );
-  const getSnapshot = (0, import_react2.useCallback)(() => {
+  const getSnapshot = (0, import_react6.useCallback)(() => {
     const plan = client.getPlan();
     return plan ?? fallbackPlan;
   }, [client, fallbackPlan]);
-  return (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, () => fallbackPlan);
+  return (0, import_react6.useSyncExternalStore)(subscribe, getSnapshot, () => fallbackPlan);
+};
+var useSchematicCreditBalance = (creditId, opts) => {
+  const client = useSchematicClient(opts);
+  const subscribe = (0, import_react6.useCallback)(
+    (callback) => client.addCreditBalanceListener(callback),
+    [client]
+  );
+  const getSnapshot = (0, import_react6.useCallback)(
+    () => creditId === void 0 ? void 0 : client.getCreditBalance(creditId),
+    [client, creditId]
+  );
+  const balance = (0, import_react6.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
+  const isPendingSubscribe = (0, import_react6.useCallback)(
+    (callback) => client.addIsPendingListener(callback),
+    [client]
+  );
+  const isPending = (0, import_react6.useSyncExternalStore)(
+    isPendingSubscribe,
+    () => client.getIsPending(),
+    () => true
+  );
+  return (0, import_react6.useMemo)(
+    () => ({
+      balance: balance?.settled ?? 0,
+      isLoading: balance === void 0 && isPending
+    }),
+    [balance, isPending]
+  );
 };
 var useSchematicIsPending = (opts) => {
   const client = useSchematicClient(opts);
-  const subscribe = (0, import_react2.useCallback)(
+  const subscribe = (0, import_react6.useCallback)(
     (callback) => client.addIsPendingListener(callback),
     [client]
   );
-  const getSnapshot = (0, import_react2.useCallback)(() => client.getIsPending(), [client]);
-  return (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, () => true);
+  const getSnapshot = (0, import_react6.useCallback)(() => client.getIsPending(), [client]);
+  return (0, import_react6.useSyncExternalStore)(subscribe, getSnapshot, () => true);
 };
 /*! Bundled license information: