@schematichq/schematic-react 1.5.0 → 1.6.0

package/dist/schematic-react.esm.js

@@ -1,4 +1,4 @@
-// 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 __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -12,6 +12,10 @@ var __commonJS = (cb, mod) => function __require() {
     throw mod = 0, e;
   }
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -29,7 +33,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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
@@ -613,6 +617,18 @@ function MetricPeriodMonthResetFromJSON(json) {
 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);
 }
@@ -644,7 +660,8 @@ function FeatureEntitlementFromJSONTyped(json, ignoreDiscriminator) {
     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) {
@@ -1014,6 +1031,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"],
@@ -1127,16 +1145,545 @@ function contextString(context) {
   }, {});
   return JSON.stringify(sortedContext);
 }
-var version = "1.5.0";
+var version = "1.7.0";
+var models_exports = {};
+__export(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;
+      }
+    }
+  }
+  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 = {};
+  _additionalHeaders = {};
   apiKey;
-  apiUrl = "https://api.schematichq.com";
+  _apiUrl = "https://api.schematichq.com";
   conn = null;
   context = {};
   debugEnabled = false;
@@ -1216,7 +1763,7 @@ var Schematic = class {
     if (this.offlineEnabled) {
       this.setIsPending(false);
     }
-    this.additionalHeaders = {
+    this._additionalHeaders = {
       "X-Schematic-Client-Version": `schematic-js@${version}`,
       ...options?.additionalHeaders ?? {}
     };
@@ -1232,7 +1779,7 @@ var Schematic = class {
     }
     this.hydrateFlagStateFromCache();
     if (options?.apiUrl !== void 0) {
-      this.apiUrl = options.apiUrl;
+      this._apiUrl = options.apiUrl;
     }
     if (options?.eventUrl !== void 0) {
       this.eventUrl = options.eventUrl;
@@ -1297,6 +1844,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)
@@ -1382,11 +1935,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
         },
@@ -1589,12 +2142,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
       },
@@ -2141,7 +2694,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
@@ -2637,7 +3190,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,
@@ -2871,23 +3424,853 @@ var notifyCreditBalanceListener = (listener, value) => {
 };
 
 // src/context/schematic.tsx
-import React, { createContext, useEffect, useMemo, useRef } from "react";
+import React4, { createContext as createContext3, useEffect as useEffect2, useMemo as useMemo5, useRef as useRef3 } from "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
+import { createContext as createContext2, useContext as useContext2, useMemo as useMemo2 } from "react";
+
+// src/i18n/context.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var EMPTY = Object.freeze({});
+var SchematicI18nContext = createContext(EMPTY);
+function SchematicI18nProvider({
+  children,
+  locale,
+  onMissingString,
+  strings,
+  translate
+}) {
+  const parent = useContext(SchematicI18nContext);
+  const value = 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__ */ jsx(SchematicI18nContext.Provider, { value, children });
+}
+function useSchematicI18n() {
+  return useContext(SchematicI18nContext);
+}
+function useSchematicLocale() {
+  return useContext(SchematicI18nContext).locale;
+}
+function useSchematicTranslate() {
+  return useContext(SchematicI18nContext).translate;
+}
+function useSchematicStrings() {
+  return useContext(SchematicI18nContext).strings;
+}
+
+// src/billing/context.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var BillingDataContext = createContext2(
+  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 useContext2(BillingDataContext) ?? missingBillingSource;
+}
+function BillingDataProvider({
+  children,
+  data,
+  locale,
+  onLoadMoreInvoices,
+  onMissingString,
+  onRefetch,
+  status,
+  strings,
+  translate
+}) {
+  const source = useMemo2(() => {
+    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__ */ jsx2(BillingDataContext.Provider, { value: source, children: /* @__PURE__ */ jsx2(
+    SchematicI18nProvider,
+    {
+      locale,
+      strings,
+      translate,
+      onMissingString,
+      children
+    }
+  ) });
+}
+
+// src/billing/hooks.ts
+import { useCallback, useMemo as useMemo3, useRef, useSyncExternalStore } from "react";
+function useStableParams(params) {
+  const key = hashKey(params);
+  const ref = 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 = useCallback(
+    (listener) => source.subscribe(name, params, listener),
+    [name, params, source]
+  );
+  const getSnapshot = useCallback(
+    () => source.handle(name, params),
+    [name, params, source]
+  );
+  return 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 = useCallback(
+    () => source.loadMoreInvoices(params),
+    [params, source]
+  );
+  return useMemo3(() => ({ ...handle, loadMore }), [handle, loadMore]);
+}
+function useInvalidateBillingData() {
+  return useBillingDataSource().invalidateAll;
+}
+
+// src/billing/provider.tsx
+import { useEffect, useMemo as useMemo4, useRef as useRef2 } from "react";
+import { jsx as jsx3 } from "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 = useRef2(initialData);
+  const install = () => {
+    billingClient?.setSession?.(session);
+  };
+  useEffect(() => {
+    const claim = billingClient?.sessionKey;
+    if (claim !== void 0 && session !== null && session !== void 0 && claim !== sessionKey(session)) {
+      console.warn(SESSION_REPLACED_MESSAGE);
+    }
+  }, []);
+  useEffect(install);
+  const seedSpent = useRef2(false);
+  const store = useMemo4(
+    () => 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]
+  );
+  useEffect(() => {
+    if (store !== void 0) {
+      seedSpent.current = true;
+    }
+  }, [store]);
+  useEffect(() => store?.connect(), [store]);
+  const source = useMemo4(() => {
+    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__ */ jsx3(
+    SchematicI18nProvider,
+    {
+      locale,
+      strings,
+      translate,
+      onMissingString,
+      children
+    }
+  );
+  if (source === void 0) {
+    return localized;
+  }
+  return /* @__PURE__ */ jsx3(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.5.0";
+var version2 = "1.6.0";
 
 // src/context/schematic.tsx
-import { jsx } from "react/jsx-runtime";
-var SchematicContext = createContext(
+import { jsx as jsx4 } from "react/jsx-runtime";
+var SchematicContext = createContext3(
   null
 );
 var SchematicProvider = ({
+  session,
+  billingClient,
   children,
   client: providedClient,
+  initialData,
+  locale,
+  onMissingString,
   publishableKey,
+  strings,
+  translate,
   ...clientOpts
 }) => {
-  const initialOptsRef = useRef({
+  const initialOptsRef = useRef3({
     publishableKey,
     useWebSocket: true,
     additionalHeaders: {
@@ -2895,7 +4278,7 @@ var SchematicProvider = ({
     },
     ...clientOpts
   });
-  const client = useMemo(() => {
+  const client = useMemo5(() => {
     if (providedClient) {
       return providedClient;
     }
@@ -2903,7 +4286,7 @@ var SchematicProvider = ({
       ...initialOptsRef.current
     });
   }, [providedClient]);
-  useEffect(() => {
+  useEffect2(() => {
     return () => {
       if (!providedClient) {
         client.cleanup().catch((error) => {
@@ -2912,16 +4295,46 @@ var SchematicProvider = ({
       }
     };
   }, [client, providedClient]);
-  const contextValue = useMemo(
+  const contextValue = useMemo5(
     () => ({
       client
     }),
     [client]
   );
-  return /* @__PURE__ */ jsx(SchematicContext.Provider, { value: contextValue, children });
+  const { apiUrl, additionalHeaders } = initialOptsRef.current;
+  const providedApiUrl = providedClient?.apiUrl;
+  const resolvedBillingClient = useMemo5(
+    () => 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__ */ jsx4(SchematicContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx4(
+    BillingProvider,
+    {
+      billingClient: resolvedBillingClient,
+      initialData,
+      locale,
+      session,
+      strings,
+      translate,
+      onMissingString,
+      children
+    }
+  ) });
 };
 var useSchematic = () => {
-  const context = React.useContext(SchematicContext);
+  const context = React4.useContext(SchematicContext);
   if (context === null) {
     throw new Error("useSchematic must be used within a SchematicProvider");
   }
@@ -2929,11 +4342,11 @@ var useSchematic = () => {
 };
 
 // src/hooks/schematic.ts
-import { useMemo as useMemo2, useSyncExternalStore, useCallback } from "react";
+import { useMemo as useMemo6, useSyncExternalStore as useSyncExternalStore2, useCallback as useCallback2 } from "react";
 var useSchematicClient = (opts) => {
   const schematic = useSchematic();
   const { client } = opts ?? {};
-  return useMemo2(() => {
+  return useMemo6(() => {
     if (client) {
       return client;
     }
@@ -2942,7 +4355,7 @@ var useSchematicClient = (opts) => {
 };
 var useSchematicContext = (opts) => {
   const client = useSchematicClient(opts);
-  return useMemo2(
+  return useMemo6(
     () => ({
       setContext: client.setContext.bind(client)
     }),
@@ -2951,33 +4364,33 @@ var useSchematicContext = (opts) => {
 };
 var useSchematicEvents = (opts) => {
   const client = useSchematicClient(opts);
-  const track = useCallback(
+  const track = useCallback2(
     (...args) => client.track(...args),
     [client]
   );
-  const identify = useCallback(
+  const identify = useCallback2(
     (...args) => client.identify(...args),
     [client]
   );
-  return useMemo2(() => ({ track, identify }), [track, identify]);
+  return useMemo6(() => ({ track, identify }), [track, identify]);
 };
 var useSchematicFlag = (key, opts) => {
   const client = useSchematicClient(opts);
   const fallback = opts?.fallback ?? false;
-  const subscribe = useCallback(
+  const subscribe = useCallback2(
     (callback) => client.addFlagValueListener(key, callback),
     [client, key]
   );
-  const getSnapshot = useCallback(() => {
+  const getSnapshot = useCallback2(() => {
     const value = client.getFlagValue(key);
     return typeof value === "undefined" ? fallback : value;
   }, [client, key, fallback]);
-  return useSyncExternalStore(subscribe, getSnapshot, () => fallback);
+  return useSyncExternalStore2(subscribe, getSnapshot, () => fallback);
 };
 var useSchematicEntitlement = (key, opts) => {
   const client = useSchematicClient(opts);
   const fallback = opts?.fallback ?? false;
-  const fallbackCheck = useMemo2(
+  const fallbackCheck = useMemo6(
     () => ({
       flag: key,
       reason: "Fallback",
@@ -2985,20 +4398,20 @@ var useSchematicEntitlement = (key, opts) => {
     }),
     [key, fallback]
   );
-  const subscribe = useCallback(
+  const subscribe = useCallback2(
     (callback) => client.addFlagCheckListener(key, callback),
     [client, key]
   );
-  const getSnapshot = useCallback(() => {
+  const getSnapshot = useCallback2(() => {
     const check = client.getFlagCheck(key);
     return check ?? fallbackCheck;
   }, [client, key, fallbackCheck]);
-  return useSyncExternalStore(subscribe, getSnapshot, () => fallbackCheck);
+  return useSyncExternalStore2(subscribe, getSnapshot, () => fallbackCheck);
 };
 var useSchematicPlan = (opts) => {
   const client = useSchematicClient(opts);
   const fallback = opts?.fallback;
-  const fallbackPlan = useMemo2(
+  const fallbackPlan = useMemo6(
     () => fallback,
     [
       fallback?.id,
@@ -3007,37 +4420,37 @@ var useSchematicPlan = (opts) => {
       fallback?.trialStatus
     ]
   );
-  const subscribe = useCallback(
+  const subscribe = useCallback2(
     (callback) => client.addPlanListener(callback),
     [client]
   );
-  const getSnapshot = useCallback(() => {
+  const getSnapshot = useCallback2(() => {
     const plan = client.getPlan();
     return plan ?? fallbackPlan;
   }, [client, fallbackPlan]);
-  return useSyncExternalStore(subscribe, getSnapshot, () => fallbackPlan);
+  return useSyncExternalStore2(subscribe, getSnapshot, () => fallbackPlan);
 };
 var useSchematicCreditBalance = (creditId, opts) => {
   const client = useSchematicClient(opts);
-  const subscribe = useCallback(
+  const subscribe = useCallback2(
     (callback) => client.addCreditBalanceListener(callback),
     [client]
   );
-  const getSnapshot = useCallback(
-    () => client.getCreditBalance(creditId),
+  const getSnapshot = useCallback2(
+    () => creditId === void 0 ? void 0 : client.getCreditBalance(creditId),
     [client, creditId]
   );
-  const balance = useSyncExternalStore(subscribe, getSnapshot, () => void 0);
-  const isPendingSubscribe = useCallback(
+  const balance = useSyncExternalStore2(subscribe, getSnapshot, () => void 0);
+  const isPendingSubscribe = useCallback2(
     (callback) => client.addIsPendingListener(callback),
     [client]
   );
-  const isPending = useSyncExternalStore(
+  const isPending = useSyncExternalStore2(
     isPendingSubscribe,
     () => client.getIsPending(),
     () => true
   );
-  return useMemo2(
+  return useMemo6(
     () => ({
       balance: balance?.settled ?? 0,
       isLoading: balance === void 0 && isPending
@@ -3047,27 +4460,42 @@ var useSchematicCreditBalance = (creditId, opts) => {
 };
 var useSchematicIsPending = (opts) => {
   const client = useSchematicClient(opts);
-  const subscribe = useCallback(
+  const subscribe = useCallback2(
     (callback) => client.addIsPendingListener(callback),
     [client]
   );
-  const getSnapshot = useCallback(() => client.getIsPending(), [client]);
-  return useSyncExternalStore(subscribe, getSnapshot, () => true);
+  const getSnapshot = useCallback2(() => client.getIsPending(), [client]);
+  return useSyncExternalStore2(subscribe, getSnapshot, () => true);
 };
 export {
+  BillingDataProvider,
+  BillingProvider,
+  DEFAULT_INVOICE_QUERY,
+  INVOICE_PAGE_SIZE,
+  InvoiceStatus,
   RuleType,
   Schematic,
+  SchematicI18nContext,
+  SchematicI18nProvider,
   SchematicProvider,
   TrialStatus,
   UsagePeriod,
+  normalizeInvoiceQuery2 as normalizeInvoiceQuery,
+  useBillingDataSource,
+  useInvalidateBillingData,
+  useInvoices,
   useSchematic,
   useSchematicContext,
   useSchematicCreditBalance,
   useSchematicEntitlement,
   useSchematicEvents,
   useSchematicFlag,
+  useSchematicI18n,
   useSchematicIsPending,
-  useSchematicPlan
+  useSchematicLocale,
+  useSchematicPlan,
+  useSchematicStrings,
+  useSchematicTranslate
 };
 /*! Bundled license information: