@hexclave/shared 1.0.41 → 1.0.42

package/dist/utils/caches.js.map

@@ -1 +1 @@
-{"version":3,"file":"caches.js","names":[],"sources":["../../src/utils/caches.tsx"],"sourcesContent":["import { isBrowserLike } from \"./env\";\nimport { DependenciesMap } from \"./maps\";\nimport { filterUndefined } from \"./objects\";\nimport { RateLimitOptions, ReactPromise, pending, rateLimited, resolved, runAsynchronously, wait } from \"./promises\";\nimport { AsyncStore } from \"./stores\";\n\n/**\n * Can be used to cache the result of a function call, for example for the `use` hook in React.\n */\nexport function cacheFunction<F extends Function>(f: F): F {\n  const dependenciesMap = new DependenciesMap<any, any>();\n\n  return ((...args: any) => {\n    if (dependenciesMap.has(args)) {\n      return dependenciesMap.get(args);\n    }\n\n    const value = f(...args);\n    dependenciesMap.set(args, value);\n    return value;\n  }) as any as F;\n}\nimport.meta.vitest?.test(\"cacheFunction\", ({ expect }) => {\n  // Test with a simple function\n  let callCount = 0;\n  const add = (a: number, b: number) => {\n    callCount++;\n    return a + b;\n  };\n\n  const cachedAdd = cacheFunction(add);\n\n  // First call should execute the function\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Second call with same args should use cached result\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Call with different args should execute the function again\n  expect(cachedAdd(2, 3)).toBe(5);\n  expect(callCount).toBe(2);\n\n  // Test with a function that returns objects\n  let objectCallCount = 0;\n  const createObject = (id: number) => {\n    objectCallCount++;\n    return { id };\n  };\n\n  const cachedCreateObject = cacheFunction(createObject);\n\n  // First call should execute the function\n  const obj1 = cachedCreateObject(1);\n  expect(obj1).toEqual({ id: 1 });\n  expect(objectCallCount).toBe(1);\n\n  // Second call with same args should use cached result\n  const obj2 = cachedCreateObject(1);\n  expect(obj2).toBe(obj1); // Same reference\n  expect(objectCallCount).toBe(1);\n});\n\n\ntype CacheStrategy = \"write-only\" | \"read-write\" | \"never\";\n\nexport class AsyncCache<D extends any[], T> {\n  private readonly _map = new DependenciesMap<D, AsyncValueCache<T>>();\n\n  constructor(\n    private readonly _fetcher: (dependencies: D) => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (key: D, refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    // nothing here yet\n  }\n\n  private _createKeyed<FunctionName extends keyof AsyncValueCache<T>>(\n    functionName: FunctionName,\n  ): (key: D, ...args: Parameters<AsyncValueCache<T>[FunctionName]>) => ReturnType<AsyncValueCache<T>[FunctionName]> {\n    return (key: D, ...args) => {\n      const valueCache = this.getValueCache(key);\n      return (valueCache[functionName] as any).apply(valueCache, args);\n    };\n  }\n\n  getValueCache(dependencies: D): AsyncValueCache<T> {\n    let cache = this._map.get(dependencies);\n    if (!cache) {\n      cache = new AsyncValueCache(\n        async () => await this._fetcher(dependencies),\n        {\n          ...this._options,\n          onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe!(dependencies, cb) : undefined,\n        },\n      );\n      this._map.set(dependencies, cache);\n    }\n    return cache;\n  }\n\n  async refreshWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.refresh());\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  async invalidateWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.invalidate().catch(() => undefined));\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  readonly isCacheAvailable = this._createKeyed(\"isCacheAvailable\");\n  readonly getIfCached = this._createKeyed(\"getIfCached\");\n  readonly getOrWait = this._createKeyed(\"getOrWait\");\n  readonly forceSetCachedValue = this._createKeyed(\"forceSetCachedValue\");\n  readonly forceSetCachedValueAsync = this._createKeyed(\"forceSetCachedValueAsync\");\n  readonly refresh = this._createKeyed(\"refresh\");\n  readonly invalidate = this._createKeyed(\"invalidate\");\n  readonly onStateChange = this._createKeyed(\"onStateChange\");\n  readonly isDirty = this._createKeyed(\"isDirty\");\n}\n\nclass AsyncValueCache<T> {\n  private _store: AsyncStore<T>;\n  private _pendingPromise: ReactPromise<T> | undefined;\n  private _fetcher: () => Promise<T>;\n  private readonly _rateLimitOptions: Omit<RateLimitOptions, \"batchCalls\">;\n  private _subscriptionsCount = 0;\n  private _unsubscribers: (() => void)[] = [];\n  private _mostRecentRefreshPromiseIndex = 0;\n\n  constructor(\n    fetcher: () => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    this._store = new AsyncStore();\n    this._rateLimitOptions = {\n      concurrency: 1,\n      throttleMs: 300,\n      ...filterUndefined(_options.rateLimiter ?? {}),\n    };\n\n\n    this._fetcher = rateLimited(fetcher, {\n      ...this._rateLimitOptions,\n      batchCalls: true,\n    });\n  }\n\n  isCacheAvailable(): boolean {\n    return this._store.isAvailable();\n  }\n\n  getIfCached() {\n    return this._store.get();\n  }\n\n  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    const cached = this.getIfCached();\n    if (cacheStrategy === \"read-write\" && cached.status === \"ok\") {\n      return resolved(cached.data);\n    }\n\n    return this._refetch(cacheStrategy);\n  }\n\n  private _set(value: T): void {\n    this._store.set(value);\n  }\n\n  private _setAsync(value: Promise<T>): ReactPromise<void> {\n    if (this._subscriptionsCount === 0 && !isBrowserLike()) {\n      // if we're in a server-like environment, we'd rather cache less aggressively to avoid memory leaks.\n      // hence, if no one is listening to this cache, let's invalidate it\n      this._invalidateCacheSoon();\n    }\n    const promise = pending(value);\n    this._pendingPromise = promise;\n    return pending(this._store.setAsync(promise).then(() => undefined));\n  }\n\n  private _refetch(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    if (cacheStrategy === \"read-write\" && this._pendingPromise) {\n      return this._pendingPromise;\n    }\n    const promise = pending(this._fetcher());\n    if (cacheStrategy === \"never\") {\n      return promise;\n    }\n    return pending(this._setAsync(promise).then(() => promise));\n  }\n\n  forceSetCachedValue(value: T): void {\n    this._set(value);\n  }\n\n  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<void> {\n    return this._setAsync(value);\n  }\n\n  /**\n   * If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.\n   */\n  async refresh(): Promise<void> {\n    // note that we do the extra check here to save a request if no one is listening to the cache anyway\n    if (this._subscriptionsCount > 0) {\n      await this.getOrWait(\"write-only\");\n    }\n  }\n\n  /**\n   * Invalidates the cache, marking it dirty (ie. it will be refreshed on the next read). If anyone is listening to the cache, it will refresh immediately.\n   */\n  async invalidate(): Promise<void> {\n    this._store.setUnavailable();\n    this._pendingPromise = undefined;\n    await this.refresh();\n  }\n\n  isDirty(): boolean {\n    return this._pendingPromise === undefined;\n  }\n\n  _invalidateCacheSoon(): void {\n    // wait a few seconds; we want to keep the cache up during this time\n    // else we do unnecessary requests if we unsubscribe and then subscribe again immediately\n    const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;\n    runAsynchronously(async () => {\n      await wait(5000);\n      if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {\n        await this.invalidate();\n      }\n    });\n  }\n\n  onStateChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {\n    const storeObj = this._store.onChange(callback);\n\n    runAsynchronously(this.getOrWait(\"read-write\"));\n\n    if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {\n      const unsubscribe = this._options.onSubscribe(() => {\n        runAsynchronously(this.refresh());\n      });\n      this._unsubscribers.push(unsubscribe);\n    }\n\n    let hasUnsubscribed = false;\n    return {\n      unsubscribe: () => {\n        if (hasUnsubscribed) return;\n        hasUnsubscribed = true;\n        storeObj.unsubscribe();\n        if (--this._subscriptionsCount === 0) {\n          this._invalidateCacheSoon();\n\n          for (const unsubscribe of this._unsubscribers) {\n            unsubscribe();\n          }\n        }\n      },\n    };\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"caches.js","names":["DependenciesMap","AsyncStore"],"sources":["../../src/utils/caches.tsx"],"sourcesContent":["import { isBrowserLike } from \"./env\";\nimport { DependenciesMap } from \"./maps\";\nimport { filterUndefined } from \"./objects\";\nimport { RateLimitOptions, ReactPromise, pending, rateLimited, resolved, runAsynchronously, wait } from \"./promises\";\nimport { AsyncStore } from \"./stores\";\n\n/**\n * Can be used to cache the result of a function call, for example for the `use` hook in React.\n */\nexport function cacheFunction<F extends Function>(f: F): F {\n  const dependenciesMap = new DependenciesMap<any, any>();\n\n  return ((...args: any) => {\n    if (dependenciesMap.has(args)) {\n      return dependenciesMap.get(args);\n    }\n\n    const value = f(...args);\n    dependenciesMap.set(args, value);\n    return value;\n  }) as any as F;\n}\nimport.meta.vitest?.test(\"cacheFunction\", ({ expect }) => {\n  // Test with a simple function\n  let callCount = 0;\n  const add = (a: number, b: number) => {\n    callCount++;\n    return a + b;\n  };\n\n  const cachedAdd = cacheFunction(add);\n\n  // First call should execute the function\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Second call with same args should use cached result\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Call with different args should execute the function again\n  expect(cachedAdd(2, 3)).toBe(5);\n  expect(callCount).toBe(2);\n\n  // Test with a function that returns objects\n  let objectCallCount = 0;\n  const createObject = (id: number) => {\n    objectCallCount++;\n    return { id };\n  };\n\n  const cachedCreateObject = cacheFunction(createObject);\n\n  // First call should execute the function\n  const obj1 = cachedCreateObject(1);\n  expect(obj1).toEqual({ id: 1 });\n  expect(objectCallCount).toBe(1);\n\n  // Second call with same args should use cached result\n  const obj2 = cachedCreateObject(1);\n  expect(obj2).toBe(obj1); // Same reference\n  expect(objectCallCount).toBe(1);\n});\n\n\ntype CacheStrategy = \"write-only\" | \"read-write\" | \"never\";\n\nexport class AsyncCache<D extends any[], T> {\n  private readonly _map = new DependenciesMap<D, AsyncValueCache<T>>();\n\n  constructor(\n    private readonly _fetcher: (dependencies: D) => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (key: D, refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    // nothing here yet\n  }\n\n  private _createKeyed<FunctionName extends keyof AsyncValueCache<T>>(\n    functionName: FunctionName,\n  ): (key: D, ...args: Parameters<AsyncValueCache<T>[FunctionName]>) => ReturnType<AsyncValueCache<T>[FunctionName]> {\n    return (key: D, ...args) => {\n      const valueCache = this.getValueCache(key);\n      return (valueCache[functionName] as any).apply(valueCache, args);\n    };\n  }\n\n  getValueCache(dependencies: D): AsyncValueCache<T> {\n    let cache = this._map.get(dependencies);\n    if (!cache) {\n      cache = new AsyncValueCache(\n        async () => await this._fetcher(dependencies),\n        {\n          ...this._options,\n          onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe!(dependencies, cb) : undefined,\n        },\n      );\n      this._map.set(dependencies, cache);\n    }\n    return cache;\n  }\n\n  async refreshWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.refresh());\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  async invalidateWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.invalidate().catch(() => undefined));\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  readonly isCacheAvailable = this._createKeyed(\"isCacheAvailable\");\n  readonly getIfCached = this._createKeyed(\"getIfCached\");\n  readonly getOrWait = this._createKeyed(\"getOrWait\");\n  readonly forceSetCachedValue = this._createKeyed(\"forceSetCachedValue\");\n  readonly forceSetCachedValueAsync = this._createKeyed(\"forceSetCachedValueAsync\");\n  readonly refresh = this._createKeyed(\"refresh\");\n  readonly invalidate = this._createKeyed(\"invalidate\");\n  readonly onStateChange = this._createKeyed(\"onStateChange\");\n  readonly isDirty = this._createKeyed(\"isDirty\");\n}\n\nclass AsyncValueCache<T> {\n  private _store: AsyncStore<T>;\n  private _pendingPromise: ReactPromise<T> | undefined;\n  private _fetcher: () => Promise<T>;\n  private readonly _rateLimitOptions: Omit<RateLimitOptions, \"batchCalls\">;\n  private _subscriptionsCount = 0;\n  private _unsubscribers: (() => void)[] = [];\n  private _mostRecentRefreshPromiseIndex = 0;\n\n  constructor(\n    fetcher: () => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    this._store = new AsyncStore();\n    this._rateLimitOptions = {\n      concurrency: 1,\n      throttleMs: 300,\n      ...filterUndefined(_options.rateLimiter ?? {}),\n    };\n\n\n    this._fetcher = rateLimited(fetcher, {\n      ...this._rateLimitOptions,\n      batchCalls: true,\n    });\n  }\n\n  isCacheAvailable(): boolean {\n    return this._store.isAvailable();\n  }\n\n  getIfCached() {\n    return this._store.get();\n  }\n\n  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    const cached = this.getIfCached();\n    if (cacheStrategy === \"read-write\" && cached.status === \"ok\") {\n      return resolved(cached.data);\n    }\n\n    return this._refetch(cacheStrategy);\n  }\n\n  private _set(value: T): void {\n    this._store.set(value);\n  }\n\n  private _setAsync(value: Promise<T>): ReactPromise<void> {\n    if (this._subscriptionsCount === 0 && !isBrowserLike()) {\n      // if we're in a server-like environment, we'd rather cache less aggressively to avoid memory leaks.\n      // hence, if no one is listening to this cache, let's invalidate it\n      this._invalidateCacheSoon();\n    }\n    const promise = pending(value);\n    this._pendingPromise = promise;\n    return pending(this._store.setAsync(promise).then(() => undefined));\n  }\n\n  private _refetch(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    if (cacheStrategy === \"read-write\" && this._pendingPromise) {\n      return this._pendingPromise;\n    }\n    const promise = pending(this._fetcher());\n    if (cacheStrategy === \"never\") {\n      return promise;\n    }\n    return pending(this._setAsync(promise).then(() => promise));\n  }\n\n  forceSetCachedValue(value: T): void {\n    this._set(value);\n  }\n\n  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<void> {\n    return this._setAsync(value);\n  }\n\n  /**\n   * If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.\n   */\n  async refresh(): Promise<void> {\n    // note that we do the extra check here to save a request if no one is listening to the cache anyway\n    if (this._subscriptionsCount > 0) {\n      await this.getOrWait(\"write-only\");\n    }\n  }\n\n  /**\n   * Invalidates the cache, marking it dirty (ie. it will be refreshed on the next read). If anyone is listening to the cache, it will refresh immediately.\n   */\n  async invalidate(): Promise<void> {\n    this._store.setUnavailable();\n    this._pendingPromise = undefined;\n    await this.refresh();\n  }\n\n  isDirty(): boolean {\n    return this._pendingPromise === undefined;\n  }\n\n  _invalidateCacheSoon(): void {\n    // wait a few seconds; we want to keep the cache up during this time\n    // else we do unnecessary requests if we unsubscribe and then subscribe again immediately\n    const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;\n    runAsynchronously(async () => {\n      await wait(5000);\n      if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {\n        await this.invalidate();\n      }\n    });\n  }\n\n  onStateChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {\n    const storeObj = this._store.onChange(callback);\n\n    runAsynchronously(this.getOrWait(\"read-write\"));\n\n    if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {\n      const unsubscribe = this._options.onSubscribe(() => {\n        runAsynchronously(this.refresh());\n      });\n      this._unsubscribers.push(unsubscribe);\n    }\n\n    let hasUnsubscribed = false;\n    return {\n      unsubscribe: () => {\n        if (hasUnsubscribed) return;\n        hasUnsubscribed = true;\n        storeObj.unsubscribe();\n        if (--this._subscriptionsCount === 0) {\n          this._invalidateCacheSoon();\n\n          for (const unsubscribe of this._unsubscribers) {\n            unsubscribe();\n          }\n        }\n      },\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/utils/cel-fields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cel-fields.d.ts","names":[],"sources":["../../src/utils/cel-fields.ts"],"mappings":";KAKY,cAAA;AAAA,KASA,iBAAA;AAAA,iBAeI,cAAA,CAAe,KAAA,EAAO,cAAA;;;;AAftC;iBAuBgB,yBAAA,CAA0B,KAAA,UAAe,KAAA;AAAA,iBAczC,eAAA,CAAgB,KAAA;AAAA,iBAIhB,iBAAA,CAAkB,KAAA;AAAA,KAUtB,kBAAA;EACV,KAAA;EACA,SAAA,EAAW,iBAAA;EACX,gBAAA;AAAA;AAAA,cAGW,aAAA,EAAe,MAAA,CAAO,cAAA,EAAgB,kBAAA;AAAA,cAUtC,eAAA,EAAgD,cAAA;AAAA,cAEhD,kBAAA,EAAoB,iBAAA;AAAA,iBAMjB,oBAAA,CAAqB,KAAA,EAAO,cAAA,GAAiB,iBAAA"}
+{"version":3,"file":"cel-fields.d.ts","names":[],"sources":["../../src/utils/cel-fields.ts"],"mappings":";KAKY,cAAA;AAAA,KASA,iBAAA;AAAA,iBAeI,cAAA,CAAe,KAAqB,EAAd,cAAc;;;AAxB1B;AAS1B;iBAuBgB,yBAAA,CAA0B,KAAA,UAAe,KAAsB;AAAA,iBAc/D,eAAA,CAAgB,KAAa;AAAA,iBAI7B,iBAAA,CAAkB,KAAa;AAAA,KAUnC,kBAAA;EACV,KAAA;EACA,SAAA,EAAW,iBAAiB;EAC5B,gBAAA;AAAA;AAAA,cAGW,aAAA,EAAe,MAAA,CAAO,cAAA,EAAgB,kBAAA;AAAA,cAUtC,eAAA,EAAgD,cAAc;AAAA,cAE9D,kBAAA,EAAoB,iBAAiB;AAAA,iBAMlC,oBAAA,CAAqB,KAAA,EAAO,cAAA,GAAiB,iBAAiB"}

package/dist/utils/cel-fields.js

@@ -1,8 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let __auth_methods_js = require("./auth-methods.js");
 let __oauth_js = require("./oauth.js");
-
 //#region src/utils/cel-fields.ts
 function isNumericField(field) {
 	return field === "riskScores.bot" || field === "riskScores.free_trial_abuse";
@@ -95,7 +93,6 @@ const conditionOperators = [
 function getOperatorsForField(field) {
 	return fieldMetadata[field].operators;
 }
-
 //#endregion
 exports.conditionFields = conditionFields;
 exports.conditionOperators = conditionOperators;
@@ -105,4 +102,5 @@ exports.getOperatorsForField = getOperatorsForField;
 exports.isNumericField = isNumericField;
 exports.unescapeCelString = unescapeCelString;
 exports.validateNumericFieldValue = validateNumericFieldValue;
+
 //# sourceMappingURL=cel-fields.js.map

package/dist/utils/cel-fields.js.map

@@ -1 +1 @@
-{"version":3,"file":"cel-fields.js","names":["signUpAuthMethodValues","standardProviders"],"sources":["../../src/utils/cel-fields.ts"],"sourcesContent":["import { signUpAuthMethodValues } from \"./auth-methods\";\nimport { standardProviders } from \"./oauth\";\n\n// ── Types ──────────────────────────────────────────────────────────────\n\nexport type ConditionField =\n  | 'email'\n  | 'countryCode'\n  | 'emailDomain'\n  | 'authMethod'\n  | 'oauthProvider'\n  | 'riskScores.bot'\n  | 'riskScores.free_trial_abuse';\n\nexport type ConditionOperator =\n  | 'equals'\n  | 'not_equals'\n  | 'greater_than'\n  | 'greater_or_equal'\n  | 'less_than'\n  | 'less_or_equal'\n  | 'matches'\n  | 'ends_with'\n  | 'starts_with'\n  | 'contains'\n  | 'in_list';\n\n// ── Helpers ────────────────────────────────────────────────────────────\n\nexport function isNumericField(field: ConditionField): boolean {\n  return field === 'riskScores.bot' || field === 'riskScores.free_trial_abuse';\n}\n\n/**\n * Validates a numeric field value is a finite integer within [0, 100].\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateNumericFieldValue(field: string, value: string | number): string | null {\n  const num = typeof value === 'number' ? value : Number(value);\n  if (!Number.isFinite(num)) {\n    return `Expected a finite number for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (!Number.isInteger(num)) {\n    return `Expected an integer for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (num < 0 || num > 100) {\n    return `Value for field \"${field}\" must be between 0 and 100, got ${num}`;\n  }\n  return null;\n}\n\nexport function escapeCelString(value: string): string {\n  return value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"');\n}\n\nexport function unescapeCelString(value: string): string {\n  return value.replace(/\\\\\\\\/g, '\\\\').replace(/\\\\\"/g, '\"');\n}\n\n// ── Field metadata ─────────────────────────────────────────────────────\n\nconst numericOperators: ConditionOperator[] = ['equals', 'not_equals', 'greater_than', 'greater_or_equal', 'less_than', 'less_or_equal'];\nconst enumOperators: ConditionOperator[] = ['equals', 'not_equals', 'in_list'];\nconst stringOperators: ConditionOperator[] = ['equals', 'not_equals', 'contains', 'starts_with', 'ends_with', 'matches', 'in_list'];\n\nexport type FieldMetadataEntry = {\n  label: string,\n  operators: ConditionOperator[],\n  predefinedValues?: string[],\n};\n\nexport const fieldMetadata: Record<ConditionField, FieldMetadataEntry> = {\n  email: { label: 'Email', operators: stringOperators },\n  countryCode: { label: 'Country Code', operators: enumOperators },\n  emailDomain: { label: 'Email Domain', operators: stringOperators },\n  authMethod: { label: 'Auth Method', operators: enumOperators, predefinedValues: [...signUpAuthMethodValues] },\n  oauthProvider: { label: 'OAuth Provider', operators: enumOperators, predefinedValues: [...standardProviders] },\n  'riskScores.bot': { label: 'Risk Score: Bot', operators: numericOperators },\n  'riskScores.free_trial_abuse': { label: 'Risk Score: Free Trial Abuse', operators: numericOperators },\n};\n\nexport const conditionFields = Object.keys(fieldMetadata) as ConditionField[];\n\nexport const conditionOperators: ConditionOperator[] = [\n  'equals', 'not_equals', 'greater_than', 'greater_or_equal',\n  'less_than', 'less_or_equal', 'matches', 'ends_with',\n  'starts_with', 'contains', 'in_list',\n];\n\nexport function getOperatorsForField(field: ConditionField): ConditionOperator[] {\n  return fieldMetadata[field].operators;\n}\n"],"mappings":";;;;;;AA6BA,SAAgB,eAAe,OAAgC;AAC7D,QAAO,UAAU,oBAAoB,UAAU;;;;;;AAOjD,SAAgB,0BAA0B,OAAe,OAAuC;CAC9F,MAAM,MAAM,OAAO,UAAU,WAAW,QAAQ,OAAO,MAAM;AAC7D,KAAI,CAAC,OAAO,SAAS,IAAI,CACvB,QAAO,uCAAuC,MAAM,UAAU,OAAO,MAAM,CAAC;AAE9E,KAAI,CAAC,OAAO,UAAU,IAAI,CACxB,QAAO,kCAAkC,MAAM,UAAU,OAAO,MAAM,CAAC;AAEzE,KAAI,MAAM,KAAK,MAAM,IACnB,QAAO,oBAAoB,MAAM,mCAAmC;AAEtE,QAAO;;AAGT,SAAgB,gBAAgB,OAAuB;AACrD,QAAO,MAAM,QAAQ,OAAO,OAAO,CAAC,QAAQ,MAAM,OAAM;;AAG1D,SAAgB,kBAAkB,OAAuB;AACvD,QAAO,MAAM,QAAQ,SAAS,KAAK,CAAC,QAAQ,QAAQ,KAAI;;AAK1D,MAAM,mBAAwC;CAAC;CAAU;CAAc;CAAgB;CAAoB;CAAa;CAAgB;AACxI,MAAM,gBAAqC;CAAC;CAAU;CAAc;CAAU;AAC9E,MAAM,kBAAuC;CAAC;CAAU;CAAc;CAAY;CAAe;CAAa;CAAW;CAAU;AAQnI,MAAa,gBAA4D;CACvE,OAAO;EAAE,OAAO;EAAS,WAAW;EAAiB;CACrD,aAAa;EAAE,OAAO;EAAgB,WAAW;EAAe;CAChE,aAAa;EAAE,OAAO;EAAgB,WAAW;EAAiB;CAClE,YAAY;EAAE,OAAO;EAAe,WAAW;EAAe,kBAAkB,CAAC,GAAGA,yCAAuB;EAAE;CAC7G,eAAe;EAAE,OAAO;EAAkB,WAAW;EAAe,kBAAkB,CAAC,GAAGC,6BAAkB;EAAE;CAC9G,kBAAkB;EAAE,OAAO;EAAmB,WAAW;EAAkB;CAC3E,+BAA+B;EAAE,OAAO;EAAgC,WAAW;EAAkB;CACtG;AAED,MAAa,kBAAkB,OAAO,KAAK,cAAc;AAEzD,MAAa,qBAA0C;CACrD;CAAU;CAAc;CAAgB;CACxC;CAAa;CAAiB;CAAW;CACzC;CAAe;CAAY;CAC5B;AAED,SAAgB,qBAAqB,OAA4C;AAC/E,QAAO,cAAc,OAAO"}
+{"version":3,"file":"cel-fields.js","names":["signUpAuthMethodValues","standardProviders"],"sources":["../../src/utils/cel-fields.ts"],"sourcesContent":["import { signUpAuthMethodValues } from \"./auth-methods\";\nimport { standardProviders } from \"./oauth\";\n\n// ── Types ──────────────────────────────────────────────────────────────\n\nexport type ConditionField =\n  | 'email'\n  | 'countryCode'\n  | 'emailDomain'\n  | 'authMethod'\n  | 'oauthProvider'\n  | 'riskScores.bot'\n  | 'riskScores.free_trial_abuse';\n\nexport type ConditionOperator =\n  | 'equals'\n  | 'not_equals'\n  | 'greater_than'\n  | 'greater_or_equal'\n  | 'less_than'\n  | 'less_or_equal'\n  | 'matches'\n  | 'ends_with'\n  | 'starts_with'\n  | 'contains'\n  | 'in_list';\n\n// ── Helpers ────────────────────────────────────────────────────────────\n\nexport function isNumericField(field: ConditionField): boolean {\n  return field === 'riskScores.bot' || field === 'riskScores.free_trial_abuse';\n}\n\n/**\n * Validates a numeric field value is a finite integer within [0, 100].\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateNumericFieldValue(field: string, value: string | number): string | null {\n  const num = typeof value === 'number' ? value : Number(value);\n  if (!Number.isFinite(num)) {\n    return `Expected a finite number for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (!Number.isInteger(num)) {\n    return `Expected an integer for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (num < 0 || num > 100) {\n    return `Value for field \"${field}\" must be between 0 and 100, got ${num}`;\n  }\n  return null;\n}\n\nexport function escapeCelString(value: string): string {\n  return value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"');\n}\n\nexport function unescapeCelString(value: string): string {\n  return value.replace(/\\\\\\\\/g, '\\\\').replace(/\\\\\"/g, '\"');\n}\n\n// ── Field metadata ─────────────────────────────────────────────────────\n\nconst numericOperators: ConditionOperator[] = ['equals', 'not_equals', 'greater_than', 'greater_or_equal', 'less_than', 'less_or_equal'];\nconst enumOperators: ConditionOperator[] = ['equals', 'not_equals', 'in_list'];\nconst stringOperators: ConditionOperator[] = ['equals', 'not_equals', 'contains', 'starts_with', 'ends_with', 'matches', 'in_list'];\n\nexport type FieldMetadataEntry = {\n  label: string,\n  operators: ConditionOperator[],\n  predefinedValues?: string[],\n};\n\nexport const fieldMetadata: Record<ConditionField, FieldMetadataEntry> = {\n  email: { label: 'Email', operators: stringOperators },\n  countryCode: { label: 'Country Code', operators: enumOperators },\n  emailDomain: { label: 'Email Domain', operators: stringOperators },\n  authMethod: { label: 'Auth Method', operators: enumOperators, predefinedValues: [...signUpAuthMethodValues] },\n  oauthProvider: { label: 'OAuth Provider', operators: enumOperators, predefinedValues: [...standardProviders] },\n  'riskScores.bot': { label: 'Risk Score: Bot', operators: numericOperators },\n  'riskScores.free_trial_abuse': { label: 'Risk Score: Free Trial Abuse', operators: numericOperators },\n};\n\nexport const conditionFields = Object.keys(fieldMetadata) as ConditionField[];\n\nexport const conditionOperators: ConditionOperator[] = [\n  'equals', 'not_equals', 'greater_than', 'greater_or_equal',\n  'less_than', 'less_or_equal', 'matches', 'ends_with',\n  'starts_with', 'contains', 'in_list',\n];\n\nexport function getOperatorsForField(field: ConditionField): ConditionOperator[] {\n  return fieldMetadata[field].operators;\n}\n"],"mappings":";;;;AA6BA,SAAgB,eAAe,OAAgC;CAC7D,OAAO,UAAU,oBAAoB,UAAU;AACjD;;;;;AAMA,SAAgB,0BAA0B,OAAe,OAAuC;CAC9F,MAAM,MAAM,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;CAC5D,IAAI,CAAC,OAAO,SAAS,GAAG,GACtB,OAAO,uCAAuC,MAAM,UAAU,OAAO,KAAK,EAAE;CAE9E,IAAI,CAAC,OAAO,UAAU,GAAG,GACvB,OAAO,kCAAkC,MAAM,UAAU,OAAO,KAAK,EAAE;CAEzE,IAAI,MAAM,KAAK,MAAM,KACnB,OAAO,oBAAoB,MAAM,mCAAmC;CAEtE,OAAO;AACT;AAEA,SAAgB,gBAAgB,OAAuB;CACrD,OAAO,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC,QAAQ,MAAM,MAAK;AACzD;AAEA,SAAgB,kBAAkB,OAAuB;CACvD,OAAO,MAAM,QAAQ,SAAS,IAAI,CAAC,CAAC,QAAQ,QAAQ,IAAG;AACzD;AAIA,MAAM,mBAAwC;CAAC;CAAU;CAAc;CAAgB;CAAoB;CAAa;AAAe;AACvI,MAAM,gBAAqC;CAAC;CAAU;CAAc;AAAS;AAC7E,MAAM,kBAAuC;CAAC;CAAU;CAAc;CAAY;CAAe;CAAa;CAAW;AAAS;AAQlI,MAAa,gBAA4D;CACvE,OAAO;EAAE,OAAO;EAAS,WAAW;CAAgB;CACpD,aAAa;EAAE,OAAO;EAAgB,WAAW;CAAc;CAC/D,aAAa;EAAE,OAAO;EAAgB,WAAW;CAAgB;CACjE,YAAY;EAAE,OAAO;EAAe,WAAW;EAAe,kBAAkB,CAAC,GAAGA,kBAAAA,sBAAsB;CAAE;CAC5G,eAAe;EAAE,OAAO;EAAkB,WAAW;EAAe,kBAAkB,CAAC,GAAGC,WAAAA,iBAAiB;CAAE;CAC7G,kBAAkB;EAAE,OAAO;EAAmB,WAAW;CAAiB;CAC1E,+BAA+B;EAAE,OAAO;EAAgC,WAAW;CAAiB;AACtG;AAEA,MAAa,kBAAkB,OAAO,KAAK,aAAa;AAExD,MAAa,qBAA0C;CACrD;CAAU;CAAc;CAAgB;CACxC;CAAa;CAAiB;CAAW;CACzC;CAAe;CAAY;AAC7B;AAEA,SAAgB,qBAAqB,OAA4C;CAC/E,OAAO,cAAc,MAAM,CAAC;AAC9B"}

package/dist/utils/cloud-hosts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloud-hosts.d.ts","names":[],"sources":["../../src/utils/cloud-hosts.tsx"],"mappings":";;AAcA;;;;;AAsBA;;;;;;;;cAtBa,gBAAA,EAAkB,aAAA;AAwC/B;;;;;AASA;AATA,iBAlBgB,sBAAA,CAAuB,YAAA;EAA4C,SAAA;EAAmB,QAAA;AAAA;;;;;;;iBAkBtF,sBAAA,CAAuB,MAAA;;;;;;iBASvB,qBAAA,CAAsB,MAAA"}
+{"version":3,"file":"cloud-hosts.d.ts","names":[],"sources":["../../src/utils/cloud-hosts.tsx"],"mappings":";;AAcA;;;;AAA4C;AAsB5C;;;;;;;;cAtBa,gBAAA,EAAkB,aAAa;AAwC5C;;;;AAAqD;AASrD;AATA,iBAlBgB,sBAAA,CAAuB,YAAA;EAA4C,SAAA;EAAmB,QAAA;AAAA;;;;;;;iBAkBtF,sBAAA,CAAuB,MAAc;;;;;;iBASrC,qBAAA,CAAsB,MAAc"}

package/dist/utils/cloud-hosts.js

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/cloud-hosts.tsx
 /**
 * Single source of truth for the stack-auth ↔ hexclave host pairs that the
@@ -62,36 +61,10 @@ function getStackAuthApiBaseUrl(apiUrl) {
 function getHexclaveApiBaseUrl(apiUrl) {
 	return getCloudApiUrlSiblings(apiUrl)?.hexclave ?? apiUrl;
 }
-(void 0)?.test("getCloudApiUrlSiblings maps both sides of each cloud pair", ({ expect }) => {
-	for (const [stackAuthHost, hexclaveHost] of CLOUD_HOST_PAIRS) {
-		const expected = {
-			stackAuth: `https://${stackAuthHost}`,
-			hexclave: `https://${hexclaveHost}`
-		};
-		for (const host of [stackAuthHost, hexclaveHost]) {
-			expect(getCloudApiUrlSiblings(host)).toEqual(expected);
-			expect(getCloudApiUrlSiblings(`https://${host}`)).toEqual(expected);
-			expect(getCloudApiUrlSiblings(`https://${host.toUpperCase()}:443`)).toEqual(expected);
-		}
-	}
-});
-(void 0)?.test("getCloudApiUrlSiblings returns null for unknown hosts", ({ expect }) => {
-	expect(getCloudApiUrlSiblings("http://localhost:8102")).toBeNull();
-	expect(getCloudApiUrlSiblings("https://my-app.vercel.app")).toBeNull();
-	expect(getCloudApiUrlSiblings(void 0)).toBeNull();
-	expect(getCloudApiUrlSiblings("")).toBeNull();
-});
-(void 0)?.test("getStackAuthApiBaseUrl / getHexclaveApiBaseUrl resolve brands and fall back", ({ expect }) => {
-	expect(getStackAuthApiBaseUrl("https://api.hexclave.com")).toBe("https://api.stack-auth.com");
-	expect(getHexclaveApiBaseUrl("https://api.stack-auth.com")).toBe("https://api.hexclave.com");
-	expect(getStackAuthApiBaseUrl("https://api.dev.stack-auth.com")).toBe("https://api.dev.stack-auth.com");
-	expect(getHexclaveApiBaseUrl("http://localhost:8102")).toBe("http://localhost:8102");
-	expect(getStackAuthApiBaseUrl("http://localhost:8102")).toBe("http://localhost:8102");
-});
-
 //#endregion
 exports.CLOUD_HOST_PAIRS = CLOUD_HOST_PAIRS;
 exports.getCloudApiUrlSiblings = getCloudApiUrlSiblings;
 exports.getHexclaveApiBaseUrl = getHexclaveApiBaseUrl;
 exports.getStackAuthApiBaseUrl = getStackAuthApiBaseUrl;
+
 //# sourceMappingURL=cloud-hosts.js.map

package/dist/utils/cloud-hosts.js.map

@@ -1 +1 @@
-{"version":3,"file":"cloud-hosts.js","names":[],"sources":["../../src/utils/cloud-hosts.tsx"],"sourcesContent":["/**\n * Single source of truth for the stack-auth ↔ hexclave host pairs that the\n * cloud deployment treats as equivalent siblings. Each\n * `[stackAuthHost, hexclaveHost]` pair is consumed in a few places:\n *\n * 1. `CLOUD_API_HOST_BY_REQUEST_HOST` in the backend's `request-api-url.ts` —\n *    the allowlist of request hosts we resolve into a JWT `iss` claim.\n * 2. `issuerHostAliases` in `tokens.tsx` — the bidirectional validator alias\n *    map, so a token issued under either host validates against the other.\n * 3. `getCloudApiUrlSiblings` below — resolves the branded base URLs used for\n *    OAuth `redirect_uri` callbacks (both at runtime and in the dashboard).\n *\n * Deriving all of these from this one list prevents drift.\n */\nexport const CLOUD_HOST_PAIRS: ReadonlyArray<readonly [string, string]> = [\n  [\"api.stack-auth.com\", \"api.hexclave.com\"],\n  [\"api.dev.stack-auth.com\", \"api.dev.hexclave.com\"],\n  [\"api.staging.stack-auth.com\", \"api.staging.hexclave.com\"],\n];\n\nfunction hostFromApiUrlOrHost(input: string): string | undefined {\n  try {\n    return new URL(input).host.split(\":\")[0].toLowerCase();\n  } catch {\n    const firstHost = input.split(\",\")[0]?.trim();\n    if (!firstHost) return undefined;\n    return firstHost.split(\":\")[0].toLowerCase();\n  }\n}\n\n/**\n * Given an API URL (or bare host), if its host belongs to a known\n * stack-auth ↔ hexclave cloud pair, return both branded base URLs. Returns\n * null for unknown hosts (localhost, vercel previews, self-host custom\n * domains).\n */\nexport function getCloudApiUrlSiblings(apiUrlOrHost: string | undefined | null): { stackAuth: string, hexclave: string } | null {\n  if (!apiUrlOrHost) return null;\n  const host = hostFromApiUrlOrHost(apiUrlOrHost);\n  if (!host) return null;\n  for (const [stackAuthHost, hexclaveHost] of CLOUD_HOST_PAIRS) {\n    if (host === stackAuthHost || host === hexclaveHost) {\n      return { stackAuth: `https://${stackAuthHost}`, hexclave: `https://${hexclaveHost}` };\n    }\n  }\n  return null;\n}\n\n/**\n * The stack-auth-branded base URL for the given deployment API URL. Used as the\n * OAuth `redirect_uri` base for shared providers and for custom providers that\n * predate `customCallbackUrl` (so existing flows keep hitting\n * `api.stack-auth.com`). Unknown hosts fall back to the input unchanged.\n */\nexport function getStackAuthApiBaseUrl(apiUrl: string): string {\n  return getCloudApiUrlSiblings(apiUrl)?.stackAuth ?? apiUrl;\n}\n\n/**\n * The hexclave-branded base URL for the given deployment API URL. Used when a\n * new custom OAuth provider is set up, so its `customCallbackUrl` points at the\n * hexclave brand. Unknown hosts fall back to the input unchanged.\n */\nexport function getHexclaveApiBaseUrl(apiUrl: string): string {\n  return getCloudApiUrlSiblings(apiUrl)?.hexclave ?? apiUrl;\n}\n\nimport.meta.vitest?.test(\"getCloudApiUrlSiblings maps both sides of each cloud pair\", ({ expect }) => {\n  for (const [stackAuthHost, hexclaveHost] of CLOUD_HOST_PAIRS) {\n    const expected = { stackAuth: `https://${stackAuthHost}`, hexclave: `https://${hexclaveHost}` };\n    for (const host of [stackAuthHost, hexclaveHost]) {\n      expect(getCloudApiUrlSiblings(host)).toEqual(expected);\n      expect(getCloudApiUrlSiblings(`https://${host}`)).toEqual(expected);\n      expect(getCloudApiUrlSiblings(`https://${host.toUpperCase()}:443`)).toEqual(expected);\n    }\n  }\n});\n\nimport.meta.vitest?.test(\"getCloudApiUrlSiblings returns null for unknown hosts\", ({ expect }) => {\n  expect(getCloudApiUrlSiblings(\"http://localhost:8102\")).toBeNull();\n  expect(getCloudApiUrlSiblings(\"https://my-app.vercel.app\")).toBeNull();\n  expect(getCloudApiUrlSiblings(undefined)).toBeNull();\n  expect(getCloudApiUrlSiblings(\"\")).toBeNull();\n});\n\nimport.meta.vitest?.test(\"getStackAuthApiBaseUrl / getHexclaveApiBaseUrl resolve brands and fall back\", ({ expect }) => {\n  expect(getStackAuthApiBaseUrl(\"https://api.hexclave.com\")).toBe(\"https://api.stack-auth.com\");\n  expect(getHexclaveApiBaseUrl(\"https://api.stack-auth.com\")).toBe(\"https://api.hexclave.com\");\n  expect(getStackAuthApiBaseUrl(\"https://api.dev.stack-auth.com\")).toBe(\"https://api.dev.stack-auth.com\");\n  expect(getHexclaveApiBaseUrl(\"http://localhost:8102\")).toBe(\"http://localhost:8102\");\n  expect(getStackAuthApiBaseUrl(\"http://localhost:8102\")).toBe(\"http://localhost:8102\");\n});\n"],"mappings":";;;;;;;;;;;;;;;;;AAcA,MAAa,mBAA6D;CACxE,CAAC,sBAAsB,mBAAmB;CAC1C,CAAC,0BAA0B,uBAAuB;CAClD,CAAC,8BAA8B,2BAA2B;CAC3D;AAED,SAAS,qBAAqB,OAAmC;AAC/D,KAAI;AACF,SAAO,IAAI,IAAI,MAAM,CAAC,KAAK,MAAM,IAAI,CAAC,GAAG,aAAa;SAChD;EACN,MAAM,YAAY,MAAM,MAAM,IAAI,CAAC,IAAI,MAAM;AAC7C,MAAI,CAAC,UAAW,QAAO;AACvB,SAAO,UAAU,MAAM,IAAI,CAAC,GAAG,aAAa;;;;;;;;;AAUhD,SAAgB,uBAAuB,cAAyF;AAC9H,KAAI,CAAC,aAAc,QAAO;CAC1B,MAAM,OAAO,qBAAqB,aAAa;AAC/C,KAAI,CAAC,KAAM,QAAO;AAClB,MAAK,MAAM,CAAC,eAAe,iBAAiB,iBAC1C,KAAI,SAAS,iBAAiB,SAAS,aACrC,QAAO;EAAE,WAAW,WAAW;EAAiB,UAAU,WAAW;EAAgB;AAGzF,QAAO;;;;;;;;AAST,SAAgB,uBAAuB,QAAwB;AAC7D,QAAO,uBAAuB,OAAO,EAAE,aAAa;;;;;;;AAQtD,SAAgB,sBAAsB,QAAwB;AAC5D,QAAO,uBAAuB,OAAO,EAAE,YAAY;;CAGrD,SAAW,KAAC,8DAAkE,EAAC,aAAU;AACvF,MAAK,MAAM,CAAC,eAAe,iBAAiB,kBAAkB;EAC5D,MAAM,WAAW;GAAE,WAAW,WAAW;GAAiB,UAAU,WAAW;GAAgB;AAC/F,OAAK,MAAM,QAAQ,CAAC,eAAe,aAAa,EAAE;AAChD,UAAO,uBAAuB,KAAK,CAAC,CAAC,QAAQ,SAAS;AACtD,UAAO,uBAAuB,WAAW,OAAO,CAAC,CAAC,QAAQ,SAAS;AACnE,UAAO,uBAAuB,WAAW,KAAK,aAAa,CAAC,MAAM,CAAC,CAAC,QAAQ,SAAS;;;EAGzF;CAEF,SAAW,KAAC,0DAA8D,EAAA,aAAW;AACnF,QAAO,uBAAuB,wBAAwB,CAAC,CAAC,UAAU;AAClE,QAAO,uBAAuB,4BAA4B,CAAC,CAAC,UAAU;AACtE,QAAO,uBAAuB,OAAU,CAAC,CAAC,UAAU;AACpD,QAAO,uBAAuB,GAAG,CAAC,CAAC,UAAU;EAC7C;CAEF,SAAW,KAAC,gFAAoF,EAAC,aAAU;AACzG,QAAO,uBAAuB,2BAA2B,CAAC,CAAC,KAAK,6BAA6B;AAC7F,QAAO,sBAAsB,6BAA6B,CAAC,CAAC,KAAK,2BAA2B;AAC5F,QAAO,uBAAuB,iCAAiC,CAAC,CAAC,KAAK,iCAAiC;AACvG,QAAO,sBAAsB,wBAAwB,CAAC,CAAC,KAAK,wBAAwB;AACpF,QAAO,uBAAuB,wBAAwB,CAAC,CAAC,KAAK,wBAAwB;EACrF"}
+{"version":3,"file":"cloud-hosts.js","names":[],"sources":["../../src/utils/cloud-hosts.tsx"],"sourcesContent":["/**\n * Single source of truth for the stack-auth ↔ hexclave host pairs that the\n * cloud deployment treats as equivalent siblings. Each\n * `[stackAuthHost, hexclaveHost]` pair is consumed in a few places:\n *\n * 1. `CLOUD_API_HOST_BY_REQUEST_HOST` in the backend's `request-api-url.ts` —\n *    the allowlist of request hosts we resolve into a JWT `iss` claim.\n * 2. `issuerHostAliases` in `tokens.tsx` — the bidirectional validator alias\n *    map, so a token issued under either host validates against the other.\n * 3. `getCloudApiUrlSiblings` below — resolves the branded base URLs used for\n *    OAuth `redirect_uri` callbacks (both at runtime and in the dashboard).\n *\n * Deriving all of these from this one list prevents drift.\n */\nexport const CLOUD_HOST_PAIRS: ReadonlyArray<readonly [string, string]> = [\n  [\"api.stack-auth.com\", \"api.hexclave.com\"],\n  [\"api.dev.stack-auth.com\", \"api.dev.hexclave.com\"],\n  [\"api.staging.stack-auth.com\", \"api.staging.hexclave.com\"],\n];\n\nfunction hostFromApiUrlOrHost(input: string): string | undefined {\n  try {\n    return new URL(input).host.split(\":\")[0].toLowerCase();\n  } catch {\n    const firstHost = input.split(\",\")[0]?.trim();\n    if (!firstHost) return undefined;\n    return firstHost.split(\":\")[0].toLowerCase();\n  }\n}\n\n/**\n * Given an API URL (or bare host), if its host belongs to a known\n * stack-auth ↔ hexclave cloud pair, return both branded base URLs. Returns\n * null for unknown hosts (localhost, vercel previews, self-host custom\n * domains).\n */\nexport function getCloudApiUrlSiblings(apiUrlOrHost: string | undefined | null): { stackAuth: string, hexclave: string } | null {\n  if (!apiUrlOrHost) return null;\n  const host = hostFromApiUrlOrHost(apiUrlOrHost);\n  if (!host) return null;\n  for (const [stackAuthHost, hexclaveHost] of CLOUD_HOST_PAIRS) {\n    if (host === stackAuthHost || host === hexclaveHost) {\n      return { stackAuth: `https://${stackAuthHost}`, hexclave: `https://${hexclaveHost}` };\n    }\n  }\n  return null;\n}\n\n/**\n * The stack-auth-branded base URL for the given deployment API URL. Used as the\n * OAuth `redirect_uri` base for shared providers and for custom providers that\n * predate `customCallbackUrl` (so existing flows keep hitting\n * `api.stack-auth.com`). Unknown hosts fall back to the input unchanged.\n */\nexport function getStackAuthApiBaseUrl(apiUrl: string): string {\n  return getCloudApiUrlSiblings(apiUrl)?.stackAuth ?? apiUrl;\n}\n\n/**\n * The hexclave-branded base URL for the given deployment API URL. Used when a\n * new custom OAuth provider is set up, so its `customCallbackUrl` points at the\n * hexclave brand. Unknown hosts fall back to the input unchanged.\n */\nexport function getHexclaveApiBaseUrl(apiUrl: string): string {\n  return getCloudApiUrlSiblings(apiUrl)?.hexclave ?? apiUrl;\n}\n\nimport.meta.vitest?.test(\"getCloudApiUrlSiblings maps both sides of each cloud pair\", ({ expect }) => {\n  for (const [stackAuthHost, hexclaveHost] of CLOUD_HOST_PAIRS) {\n    const expected = { stackAuth: `https://${stackAuthHost}`, hexclave: `https://${hexclaveHost}` };\n    for (const host of [stackAuthHost, hexclaveHost]) {\n      expect(getCloudApiUrlSiblings(host)).toEqual(expected);\n      expect(getCloudApiUrlSiblings(`https://${host}`)).toEqual(expected);\n      expect(getCloudApiUrlSiblings(`https://${host.toUpperCase()}:443`)).toEqual(expected);\n    }\n  }\n});\n\nimport.meta.vitest?.test(\"getCloudApiUrlSiblings returns null for unknown hosts\", ({ expect }) => {\n  expect(getCloudApiUrlSiblings(\"http://localhost:8102\")).toBeNull();\n  expect(getCloudApiUrlSiblings(\"https://my-app.vercel.app\")).toBeNull();\n  expect(getCloudApiUrlSiblings(undefined)).toBeNull();\n  expect(getCloudApiUrlSiblings(\"\")).toBeNull();\n});\n\nimport.meta.vitest?.test(\"getStackAuthApiBaseUrl / getHexclaveApiBaseUrl resolve brands and fall back\", ({ expect }) => {\n  expect(getStackAuthApiBaseUrl(\"https://api.hexclave.com\")).toBe(\"https://api.stack-auth.com\");\n  expect(getHexclaveApiBaseUrl(\"https://api.stack-auth.com\")).toBe(\"https://api.hexclave.com\");\n  expect(getStackAuthApiBaseUrl(\"https://api.dev.stack-auth.com\")).toBe(\"https://api.dev.stack-auth.com\");\n  expect(getHexclaveApiBaseUrl(\"http://localhost:8102\")).toBe(\"http://localhost:8102\");\n  expect(getStackAuthApiBaseUrl(\"http://localhost:8102\")).toBe(\"http://localhost:8102\");\n});\n"],"mappings":";;;;;;;;;;;;;;;;AAcA,MAAa,mBAA6D;CACxE,CAAC,sBAAsB,kBAAkB;CACzC,CAAC,0BAA0B,sBAAsB;CACjD,CAAC,8BAA8B,0BAA0B;AAC3D;AAEA,SAAS,qBAAqB,OAAmC;CAC/D,IAAI;EACF,OAAO,IAAI,IAAI,KAAK,CAAC,CAAC,KAAK,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,YAAY;CACvD,QAAQ;EACN,MAAM,YAAY,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK;EAC5C,IAAI,CAAC,WAAW,OAAO,KAAA;EACvB,OAAO,UAAU,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,YAAY;CAC7C;AACF;;;;;;;AAQA,SAAgB,uBAAuB,cAAyF;CAC9H,IAAI,CAAC,cAAc,OAAO;CAC1B,MAAM,OAAO,qBAAqB,YAAY;CAC9C,IAAI,CAAC,MAAM,OAAO;CAClB,KAAK,MAAM,CAAC,eAAe,iBAAiB,kBAC1C,IAAI,SAAS,iBAAiB,SAAS,cACrC,OAAO;EAAE,WAAW,WAAW;EAAiB,UAAU,WAAW;CAAe;CAGxF,OAAO;AACT;;;;;;;AAQA,SAAgB,uBAAuB,QAAwB;CAC7D,OAAO,uBAAuB,MAAM,CAAC,EAAE,aAAa;AACtD;;;;;;AAOA,SAAgB,sBAAsB,QAAwB;CAC5D,OAAO,uBAAuB,MAAM,CAAC,EAAE,YAAY;AACrD"}

package/dist/utils/compile-time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile-time.d.ts","names":[],"sources":["../../src/utils/compile-time.tsx"],"mappings":";;AAKA;;;;iBAAgB,yBAAA,GAAA,CAA6B,CAAA,EAAG,CAAA,GAAI,CAAA"}
+{"version":3,"file":"compile-time.d.ts","names":[],"sources":["../../src/utils/compile-time.tsx"],"mappings":";;AAKA;;;;iBAAgB,yBAAA,IAA6B,CAAA,EAAG,CAAA,GAAI,CAAC"}

package/dist/utils/compile-time.js

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/compile-time.tsx
 /**
 * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some
@@ -10,7 +9,7 @@ function scrambleDuringCompileTime(t) {
 	if (Math.random() < 1e-5 && Math.random() > .99999 && Math.random() < 1e-5 && Math.random() > .99999) return "this will never happen";
 	return t;
 }
-
 //#endregion
 exports.scrambleDuringCompileTime = scrambleDuringCompileTime;
+
 //# sourceMappingURL=compile-time.js.map

package/dist/utils/compile-time.js.map

@@ -1 +1 @@
-{"version":3,"file":"compile-time.js","names":[],"sources":["../../src/utils/compile-time.tsx"],"sourcesContent":["/**\n * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some\n * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed\n * to exist at runtime).\n */\nexport function scrambleDuringCompileTime<T>(t: T): T {\n  if (Math.random() < 0.00001 && Math.random() > 0.99999 && Math.random() < 0.00001 && Math.random() > 0.99999) {\n    return \"this will never happen\" as any;\n  }\n  return t;\n}\n"],"mappings":";;;;;;;;AAKA,SAAgB,0BAA6B,GAAS;AACpD,KAAI,KAAK,QAAQ,GAAG,QAAW,KAAK,QAAQ,GAAG,UAAW,KAAK,QAAQ,GAAG,QAAW,KAAK,QAAQ,GAAG,OACnG,QAAO;AAET,QAAO"}
+{"version":3,"file":"compile-time.js","names":[],"sources":["../../src/utils/compile-time.tsx"],"sourcesContent":["/**\n * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some\n * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed\n * to exist at runtime).\n */\nexport function scrambleDuringCompileTime<T>(t: T): T {\n  if (Math.random() < 0.00001 && Math.random() > 0.99999 && Math.random() < 0.00001 && Math.random() > 0.99999) {\n    return \"this will never happen\" as any;\n  }\n  return t;\n}\n"],"mappings":";;;;;;;AAKA,SAAgB,0BAA6B,GAAS;CACpD,IAAI,KAAK,OAAO,IAAI,QAAW,KAAK,OAAO,IAAI,UAAW,KAAK,OAAO,IAAI,QAAW,KAAK,OAAO,IAAI,QACnG,OAAO;CAET,OAAO;AACT"}

package/dist/utils/country-codes.d.ts

@@ -1,11 +1,2 @@
-//#region src/utils/country-codes.d.ts
-declare function normalizeCountryCode(countryCode: string): string;
-declare function isValidCountryCode(countryCode: string): boolean;
-/**
- * Validates and normalizes a country code value (single string or array).
- * Returns null if valid, or an error message string if invalid.
- */
-declare function validateCountryCode(value: string | string[]): string | null;
-//#endregion
-export { isValidCountryCode, normalizeCountryCode, validateCountryCode };
-//# sourceMappingURL=country-codes.d.ts.map
+import { n as normalizeCountryCode, r as validateCountryCode, t as isValidCountryCode } from "../country-codes-CRWDroBE.js";
+export { isValidCountryCode, normalizeCountryCode, validateCountryCode };

package/dist/utils/country-codes.js

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/country-codes.ts
 function normalizeCountryCode(countryCode) {
 	return countryCode.trim().toUpperCase();
@@ -17,24 +16,9 @@ function validateCountryCode(value) {
 	if (values.length === 0) return "At least one country code is required";
 	return values.every((v) => isValidCountryCode(v)) ? null : "Country code must be a 2-letter code";
 }
-(void 0)?.test("country codes", ({ expect }) => {
-	expect(normalizeCountryCode(" us ")).toBe("US");
-	expect(isValidCountryCode("us")).toBe(true);
-	expect(isValidCountryCode("US")).toBe(true);
-	expect(isValidCountryCode("ZZ")).toBe(true);
-	expect(isValidCountryCode("usa")).toBe(false);
-	expect(isValidCountryCode("a")).toBe(false);
-	expect(isValidCountryCode("")).toBe(false);
-	expect(isValidCountryCode("12")).toBe(false);
-	expect(validateCountryCode("US")).toBeNull();
-	expect(validateCountryCode("zz")).toBeNull();
-	expect(validateCountryCode(["US", "CA"])).toBeNull();
-	expect(validateCountryCode([])).toBe("At least one country code is required");
-	expect(validateCountryCode(["US", "123"])).toBe("Country code must be a 2-letter code");
-});
-
 //#endregion
 exports.isValidCountryCode = isValidCountryCode;
 exports.normalizeCountryCode = normalizeCountryCode;
 exports.validateCountryCode = validateCountryCode;
+
 //# sourceMappingURL=country-codes.js.map

package/dist/utils/country-codes.js.map

@@ -1 +1 @@
-{"version":3,"file":"country-codes.js","names":[],"sources":["../../src/utils/country-codes.ts"],"sourcesContent":["export function normalizeCountryCode(countryCode: string): string {\n  return countryCode.trim().toUpperCase();\n}\n\nexport function isValidCountryCode(countryCode: string): boolean {\n  const normalized = normalizeCountryCode(countryCode);\n  return /^[A-Z]{2}$/.test(normalized);\n}\n\n/**\n * Validates and normalizes a country code value (single string or array).\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateCountryCode(value: string | string[]): string | null {\n  const values = Array.isArray(value) ? value : [value];\n  if (values.length === 0) {\n    return \"At least one country code is required\";\n  }\n  return values.every(v => isValidCountryCode(v))\n    ? null\n    : \"Country code must be a 2-letter code\";\n}\n\nimport.meta.vitest?.test(\"country codes\", ({ expect }) => {\n  expect(normalizeCountryCode(\" us \")).toBe(\"US\");\n  expect(isValidCountryCode(\"us\")).toBe(true);\n  expect(isValidCountryCode(\"US\")).toBe(true);\n  expect(isValidCountryCode(\"ZZ\")).toBe(true);\n  expect(isValidCountryCode(\"usa\")).toBe(false);\n  expect(isValidCountryCode(\"a\")).toBe(false);\n  expect(isValidCountryCode(\"\")).toBe(false);\n  expect(isValidCountryCode(\"12\")).toBe(false);\n\n  expect(validateCountryCode(\"US\")).toBeNull();\n  expect(validateCountryCode(\"zz\")).toBeNull();\n  expect(validateCountryCode([\"US\", \"CA\"])).toBeNull();\n  expect(validateCountryCode([])).toBe(\"At least one country code is required\");\n  expect(validateCountryCode([\"US\", \"123\"])).toBe(\"Country code must be a 2-letter code\");\n});\n"],"mappings":";;;AAAA,SAAgB,qBAAqB,aAA6B;AAChE,QAAO,YAAY,MAAM,CAAC,aAAa;;AAGzC,SAAgB,mBAAmB,aAA8B;CAC/D,MAAM,aAAa,qBAAqB,YAAY;AACpD,QAAO,aAAa,KAAK,WAAW;;;;;;AAOtC,SAAgB,oBAAoB,OAAyC;CAC3E,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;AACrD,KAAI,OAAO,WAAW,EACpB,QAAO;AAET,QAAO,OAAO,OAAM,MAAK,mBAAmB,EAAE,CAAA,GAC1C,OACA;;CAGN,SAAW,KAAC,kBAAsB,EAAA,aAAW;AAC3C,QAAO,qBAAqB,OAAO,CAAC,CAAC,KAAK,KAAK;AAC/C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,KAAK;AAC3C,QAAO,mBAAmB,MAAM,CAAC,CAAC,KAAK,MAAM;AAC7C,QAAO,mBAAmB,IAAI,CAAC,CAAC,KAAK,MAAM;AAC3C,QAAO,mBAAmB,GAAG,CAAC,CAAC,KAAK,MAAM;AAC1C,QAAO,mBAAmB,KAAK,CAAC,CAAC,KAAK,MAAM;AAE5C,QAAO,oBAAoB,KAAK,CAAC,CAAC,UAAU;AAC5C,QAAO,oBAAoB,KAAK,CAAC,CAAC,UAAU;AAC5C,QAAO,oBAAoB,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,UAAU;AACpD,QAAO,oBAAoB,EAAE,CAAC,CAAC,CAAC,KAAK,wCAAwC;AAC7E,QAAO,oBAAoB,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,KAAK,uCAAuC;EACvF"}
+{"version":3,"file":"country-codes.js","names":[],"sources":["../../src/utils/country-codes.ts"],"sourcesContent":["export function normalizeCountryCode(countryCode: string): string {\n  return countryCode.trim().toUpperCase();\n}\n\nexport function isValidCountryCode(countryCode: string): boolean {\n  const normalized = normalizeCountryCode(countryCode);\n  return /^[A-Z]{2}$/.test(normalized);\n}\n\n/**\n * Validates and normalizes a country code value (single string or array).\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateCountryCode(value: string | string[]): string | null {\n  const values = Array.isArray(value) ? value : [value];\n  if (values.length === 0) {\n    return \"At least one country code is required\";\n  }\n  return values.every(v => isValidCountryCode(v))\n    ? null\n    : \"Country code must be a 2-letter code\";\n}\n\nimport.meta.vitest?.test(\"country codes\", ({ expect }) => {\n  expect(normalizeCountryCode(\" us \")).toBe(\"US\");\n  expect(isValidCountryCode(\"us\")).toBe(true);\n  expect(isValidCountryCode(\"US\")).toBe(true);\n  expect(isValidCountryCode(\"ZZ\")).toBe(true);\n  expect(isValidCountryCode(\"usa\")).toBe(false);\n  expect(isValidCountryCode(\"a\")).toBe(false);\n  expect(isValidCountryCode(\"\")).toBe(false);\n  expect(isValidCountryCode(\"12\")).toBe(false);\n\n  expect(validateCountryCode(\"US\")).toBeNull();\n  expect(validateCountryCode(\"zz\")).toBeNull();\n  expect(validateCountryCode([\"US\", \"CA\"])).toBeNull();\n  expect(validateCountryCode([])).toBe(\"At least one country code is required\");\n  expect(validateCountryCode([\"US\", \"123\"])).toBe(\"Country code must be a 2-letter code\");\n});\n"],"mappings":";;AAAA,SAAgB,qBAAqB,aAA6B;CAChE,OAAO,YAAY,KAAK,CAAC,CAAC,YAAY;AACxC;AAEA,SAAgB,mBAAmB,aAA8B;CAC/D,MAAM,aAAa,qBAAqB,WAAW;CACnD,OAAO,aAAa,KAAK,UAAU;AACrC;;;;;AAMA,SAAgB,oBAAoB,OAAyC;CAC3E,MAAM,SAAS,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK;CACpD,IAAI,OAAO,WAAW,GACpB,OAAO;CAET,OAAO,OAAO,OAAM,MAAK,mBAAmB,CAAC,CAAC,IAC1C,OACA;AACN"}

package/dist/utils/crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.d.ts","names":[],"sources":["../../src/utils/crypto.tsx"],"mappings":";iBAMgB,oBAAA,CAAqB,KAAA,EAAO,UAAA,UAAoB,KAAA;AAAhE;;;;AAAA,iBAcgB,0BAAA,CAA2B,gBAAA;AAAA,iBAiCrB,OAAA,CAAA;EAAU,OAAA;EAAS,MAAA;EAAQ;AAAA;EAAW,OAAA;EAAiB,MAAA,WAAiB,UAAA;EAAY,KAAA,EAAO,UAAA;AAAA,IAAY,OAAA,CAAA,UAAA,CAAA,WAAA;AAAA,iBAcvG,OAAA,CAAA;EAAU,OAAA;EAAS,MAAA;EAAQ;AAAA;EAAY,OAAA;EAAiB,MAAA,WAAiB,UAAA;EAAY,MAAA,EAAQ,UAAA;AAAA,IAAY,OAAA;;;;;;;;;;;KAyCnH,WAAA;EACV,OAAA;EACA,IAAA,YAAgB,UAAA;EAChB,KAAA,YAAiB,UAAA;EACjB,KAAA,WAAgB,UAAA;AAAA;AAAA,iBAGI,IAAA,CAAK,OAAA,EAAS,WAAA,GAAW,OAAA,CAAA,UAAA,CAAA,WAAA;AAAA,iBAIzB,YAAA,CAAa,OAAA,EAAS,WAAA;EAAgB,UAAA;AAAA,IAAoB,OAAA,CAAA,UAAA,CAAA,WAAA"}
+{"version":3,"file":"crypto.d.ts","names":[],"sources":["../../src/utils/crypto.tsx"],"mappings":";iBAMgB,oBAAA,CAAqB,KAAA,EAAO,UAAA,UAAoB,KAAK;AAArE;;;;AAAA,iBAcgB,0BAAA,CAA2B,gBAA8B;AAAA,iBAiCnD,OAAA;EAAU,OAAA;EAAS,MAAA;EAAQ;AAAA;EAAW,OAAA;EAAiB,MAAA,WAAiB,UAAA;EAAY,KAAA,EAAO,UAAA;AAAA,IAAY,OAAA,CAAA,UAAA,CAAA,WAAA;AAAA,iBAcvG,OAAA;EAAU,OAAA;EAAS,MAAA;EAAQ;AAAA;EAAY,OAAA;EAAiB,MAAA,WAAiB,UAAA;EAAY,MAAA,EAAQ,UAAA;AAAA,IAAY,OAAA;;;;;;;;;;;KAyCnH,WAAA;EACV,OAAA;EACA,IAAA,YAAgB,UAAA;EAChB,KAAA,YAAiB,UAAA;EACjB,KAAA,WAAgB,UAAA;AAAA;AAAA,iBAGI,IAAA,CAAK,OAAA,EAAS,WAAA,GAAW,OAAA,CAAA,UAAA,CAAA,WAAA;AAAA,iBAIzB,YAAA,CAAa,OAAA,EAAS,WAAA;EAAgB,UAAA;AAAA,IAAoB,OAAA,CAAA,UAAA,CAAA,WAAA"}

package/dist/utils/crypto.js

@@ -1,11 +1,9 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let __bytes_js = require("./bytes.js");
 let __errors_js = require("./errors.js");
 let __globals_js = require("./globals.js");
 let __results_js = require("./results.js");
 let __typed_arrays_js = require("./typed-arrays.js");
-
 //#region src/utils/crypto.tsx
 function generateRandomValues(array) {
 	if (!__globals_js.globalVar.crypto) throw new __errors_js.HexclaveAssertionError("Crypto API is not available in this environment. Are you using an old browser?");
@@ -41,8 +39,8 @@ async function getDerivedSymmetricKey(purpose, secret, salt) {
 	}, false, ["encrypt", "decrypt"]);
 }
 async function encrypt({ purpose, secret, value }) {
-	const iv = crypto.getRandomValues(new Uint8Array(12));
-	const salt = crypto.getRandomValues(new Uint8Array(16));
+	const iv = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(12));
+	const salt = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
 	const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);
 	const cipher = await crypto.subtle.encrypt({
 		name: "AES-GCM",
@@ -73,27 +71,6 @@ async function decrypt({ purpose, secret, cipher }) {
 		throw e;
 	}
 }
-(void 0)?.test("encrypt & decrypt", async ({ expect }) => {
-	const encryptAndDecrypt = async (encryptPurpose, decryptPurpose, encryptSecret, decryptSecret, value) => {
-		return await decrypt({
-			purpose: decryptPurpose,
-			secret: decryptSecret,
-			cipher: await encrypt({
-				purpose: encryptPurpose,
-				secret: encryptSecret,
-				value
-			})
-		});
-	};
-	const exampleBytes = new TextEncoder().encode("hello");
-	const exampleKey1 = crypto.getRandomValues(new Uint8Array(32));
-	const exampleKey2 = crypto.getRandomValues(new Uint8Array(32));
-	expect(await encryptAndDecrypt("p", "p", "secret", "secret", exampleBytes)).toEqual(__results_js.Result.ok(exampleBytes));
-	expect(await encryptAndDecrypt("p", "p", exampleKey1, exampleKey1, exampleBytes)).toEqual(__results_js.Result.ok(exampleBytes));
-	expect(await encryptAndDecrypt("p", "p", exampleKey1, "secret", exampleBytes)).toEqual(__results_js.Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
-	expect(await encryptAndDecrypt("p", "p", exampleKey1, exampleKey2, exampleBytes)).toEqual(__results_js.Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
-	expect(await encryptAndDecrypt("p", "not-p", exampleKey1, exampleKey1, exampleBytes)).toEqual(__results_js.Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
-});
 async function hash(options) {
 	return await iteratedHash({
 		...options,
@@ -116,95 +93,6 @@ async function iteratedHash(options) {
 		hash: "SHA-256"
 	}, input, 256));
 }
-(void 0)?.test("iteratedHash", async ({ expect }) => {
-	const valueBytes = new TextEncoder().encode("hello");
-	const incrementBytes = new Uint8Array([
-		1,
-		2,
-		3,
-		4,
-		5,
-		6,
-		7,
-		8,
-		9,
-		10,
-		11,
-		12,
-		13,
-		14,
-		15,
-		16
-	]);
-	const hash = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		iterations: 1e5
-	});
-	const hash2 = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		iterations: 1e5
-	});
-	const hashWithDifferentPurpose = await iteratedHash({
-		purpose: "different-purpose",
-		value: valueBytes,
-		iterations: 1e5
-	});
-	const hashWithEmptySalt = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		salt: new Uint8Array(0),
-		iterations: 1e5
-	});
-	const hashWithDifferentSalt = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		salt: incrementBytes,
-		iterations: 1e5
-	});
-	const hashWithEmptyExtra = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		extra: new Uint8Array(0),
-		iterations: 1e5
-	});
-	const hashWithDifferentExtra = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		extra: incrementBytes,
-		iterations: 1e5
-	});
-	const hashWithDifferentValue = await iteratedHash({
-		purpose: "purpose",
-		value: new TextEncoder().encode("hello2"),
-		iterations: 1e5
-	});
-	const hashWithDifferentSaltAndExtra = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		salt: incrementBytes,
-		extra: incrementBytes,
-		iterations: 1e5
-	});
-	const hashWithDifferentIterations = await iteratedHash({
-		purpose: "purpose",
-		value: valueBytes,
-		iterations: 100001
-	});
-	expect(hash).toEqual(hash2);
-	expect(hash).not.toEqual(hashWithDifferentPurpose);
-	expect(hash).toEqual(hashWithEmptySalt);
-	expect(hash).not.toEqual(hashWithDifferentSalt);
-	expect(hash).toEqual(hashWithEmptyExtra);
-	expect(hash).not.toEqual(hashWithDifferentExtra);
-	expect(hash).not.toEqual(hashWithDifferentValue);
-	expect(hash).not.toEqual(hashWithDifferentIterations);
-	expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentExtra);
-	expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentSaltAndExtra);
-	expect(hashWithDifferentExtra).not.toEqual(hashWithDifferentSaltAndExtra);
-});
-
 //#endregion
 exports.decrypt = decrypt;
 exports.encrypt = encrypt;
@@ -212,4 +100,5 @@ exports.generateRandomValues = generateRandomValues;
 exports.generateSecureRandomString = generateSecureRandomString;
 exports.hash = hash;
 exports.iteratedHash = iteratedHash;
+
 //# sourceMappingURL=crypto.js.map

package/dist/utils/crypto.js.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.js","names":[],"sources":["../../src/utils/crypto.tsx"],"sourcesContent":["import { encodeBase32, encodeBase64 } from \"./bytes\";\nimport { HexclaveAssertionError } from \"./errors\";\nimport { globalVar } from \"./globals\";\nimport { Result } from \"./results\";\nimport { toArrayBufferBacked } from \"./typed-arrays\";\n\nexport function generateRandomValues(array: Uint8Array): typeof array {\n  if (!globalVar.crypto) {\n    throw new HexclaveAssertionError(\"Crypto API is not available in this environment. Are you using an old browser?\");\n  }\n  if (!globalVar.crypto.getRandomValues) {\n    throw new HexclaveAssertionError(\"crypto.getRandomValues is not available in this environment. Are you using an old browser?\");\n  }\n  return globalVar.crypto.getRandomValues(array);\n}\n\n/**\n * Generates a secure alphanumeric string using the system's cryptographically secure\n * random number generator.\n */\nexport function generateSecureRandomString(minBitsOfEntropy: number = 224) {\n  const base32CharactersCount = Math.ceil(minBitsOfEntropy / 5);\n  const bytesCount = Math.ceil(base32CharactersCount * 5 / 8);\n  const randomBytes = generateRandomValues(new Uint8Array(bytesCount));\n  const str = encodeBase32(randomBytes);\n  return str.slice(str.length - base32CharactersCount).toLowerCase();\n}\n\nasync function getDerivedSymmetricKey(purpose: string, secret: string | Uint8Array, salt: Uint8Array) {\n  const secretBytes = typeof secret === \"string\" ? new TextEncoder().encode(secret) : toArrayBufferBacked(secret);\n  const originalSecretKey = await crypto.subtle.importKey(\"raw\", secretBytes, \"HKDF\", false, [\"deriveKey\"]);\n  return await crypto.subtle.deriveKey(\n    {\n      name: \"HKDF\",\n      salt: toArrayBufferBacked(salt),\n      hash: \"SHA-256\",\n      // NOTE (Hexclave rebrand): do NOT rename this \"stack-*\" literal. It is a domain-separation\n      // tag baked into HKDF key derivation; changing it would derive different keys and make all\n      // previously-encrypted data undecryptable. It is an internal constant, never user-visible.\n      info: new TextEncoder().encode(JSON.stringify([\n        \"stack-crypto-helper-derived-symmetric-key\",\n        purpose,\n        typeof secret === \"string\" ? \"string-key\" : \"binary-key\",\n        encodeBase64(salt),\n      ])),\n    },\n    originalSecretKey,\n    { name: \"AES-GCM\", length: 256 },\n    false,\n    [\"encrypt\", \"decrypt\"]\n  );\n}\n\nexport async function encrypt({ purpose, secret, value }: { purpose: string, secret: string | Uint8Array, value: Uint8Array }) {\n  const iv = crypto.getRandomValues(new Uint8Array(12));\n  const salt = crypto.getRandomValues(new Uint8Array(16));\n  const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);\n\n  const cipher = await crypto.subtle.encrypt({\n    name: \"AES-GCM\",\n    iv,\n  }, derivedSecretKey, toArrayBufferBacked(value));\n\n  const version = [0x01, 0x00];\n  return new Uint8Array([...version, ...salt, ...iv, ...new Uint8Array(cipher)]);\n}\n\nexport async function decrypt({ purpose, secret, cipher }: { purpose: string, secret: string | Uint8Array, cipher: Uint8Array }) {\n  const version = cipher.slice(0, 2);\n  if (version[0] !== 0x01 || version[1] !== 0x00) throw new HexclaveAssertionError(\"Invalid ciphertext version in decrypt(...); expected 0x0100\", { purpose });\n  const salt = cipher.slice(2, 18);\n  const iv = cipher.slice(18, 30);\n  const cipherBytes = cipher.slice(30);\n  const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);\n\n  try {\n    const plaintext = await crypto.subtle.decrypt({\n      name: \"AES-GCM\",\n      iv,\n    }, derivedSecretKey, cipherBytes);\n    return Result.ok(new Uint8Array(plaintext));\n  } catch (e) {\n    if (e instanceof DOMException && e.name === \"OperationError\") {\n      return Result.error(new Error(\"Invalid ciphertext or secret when decrypting encrypted value\", { cause: e }));\n    }\n    throw e;\n  }\n}\n\nimport.meta.vitest?.test(\"encrypt & decrypt\", async ({ expect }) => {\n  const encryptAndDecrypt = async (encryptPurpose: string, decryptPurpose: string, encryptSecret: string | Uint8Array, decryptSecret: string | Uint8Array, value: Uint8Array) => {\n    const encrypted = await encrypt({ purpose: encryptPurpose, secret: encryptSecret, value });\n    const decrypted = await decrypt({ purpose: decryptPurpose, secret: decryptSecret, cipher: encrypted });\n    return decrypted;\n  };\n\n  const exampleBytes = new TextEncoder().encode(\"hello\");\n\n  const exampleKey1 = crypto.getRandomValues(new Uint8Array(32));\n  const exampleKey2 = crypto.getRandomValues(new Uint8Array(32));\n\n  expect(await encryptAndDecrypt(\"p\", \"p\", \"secret\", \"secret\", exampleBytes)).toEqual(Result.ok(exampleBytes));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.ok(exampleBytes));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, \"secret\", exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, exampleKey2, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n  expect(await encryptAndDecrypt(\"p\", \"not-p\", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n});\n\nexport type HashOptions = {\n  purpose: string,\n  salt?: string | Uint8Array,\n  extra?: string | Uint8Array,\n  value: string | Uint8Array,\n};\n\nexport async function hash(options: HashOptions) {\n  return await iteratedHash({ ...options, iterations: 1 });\n}\n\nexport async function iteratedHash(options: HashOptions & { iterations: number }) {\n  const stringOrUint8ArrayToUint8Array = (value: string | Uint8Array) => typeof value === \"string\" ? new TextEncoder().encode(value) : toArrayBufferBacked(value);\n  const stringOrUint8ArrayToBase64 = (value: string | Uint8Array) => encodeBase64(stringOrUint8ArrayToUint8Array(value));\n  const input = await crypto.subtle.importKey(\n    \"raw\",\n    stringOrUint8ArrayToUint8Array(options.value),\n    \"PBKDF2\",\n    false,\n    [\"deriveBits\"]\n  );\n  return new Uint8Array(await crypto.subtle.deriveBits({\n    name: \"PBKDF2\",\n    // NOTE (Hexclave rebrand): do NOT rename this \"stack-*\" literal. It is a domain-separation tag\n    // mixed into the PBKDF2 salt; changing it would change every hash output and break verification\n    // of all previously-hashed values. It is an internal constant, never user-visible.\n    salt: new TextEncoder().encode(JSON.stringify([\n      \"stack-crypto-helper-iterated-hash\",\n      options.purpose,\n      stringOrUint8ArrayToBase64(options.salt ?? \"\"),\n      stringOrUint8ArrayToBase64(options.extra ?? \"\"),\n    ])),\n    iterations: options.iterations,\n    hash: \"SHA-256\",\n  }, input, 256));\n}\n\nimport.meta.vitest?.test(\"iteratedHash\", async ({ expect }) => {\n  const valueBytes = new TextEncoder().encode(\"hello\");\n  const incrementBytes = new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10]);\n\n  const hash = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_000 });\n  const hash2 = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_000 });\n  const hashWithDifferentPurpose = await iteratedHash({ purpose: \"different-purpose\", value: valueBytes, iterations: 100_000 });\n  const hashWithEmptySalt = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: new Uint8Array(0), iterations: 100_000 });\n  const hashWithDifferentSalt = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: incrementBytes, iterations: 100_000 });\n  const hashWithEmptyExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, extra: new Uint8Array(0), iterations: 100_000 });\n  const hashWithDifferentExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, extra: incrementBytes, iterations: 100_000 });\n  const hashWithDifferentValue = await iteratedHash({ purpose: \"purpose\", value: new TextEncoder().encode(\"hello2\"), iterations: 100_000 });\n  const hashWithDifferentSaltAndExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: incrementBytes, extra: incrementBytes, iterations: 100_000 });\n  const hashWithDifferentIterations = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_001 });\n\n\n  expect(hash).toEqual(hash2);\n  expect(hash).not.toEqual(hashWithDifferentPurpose);\n  expect(hash).toEqual(hashWithEmptySalt);\n  expect(hash).not.toEqual(hashWithDifferentSalt);\n  expect(hash).toEqual(hashWithEmptyExtra);\n  expect(hash).not.toEqual(hashWithDifferentExtra);\n  expect(hash).not.toEqual(hashWithDifferentValue);\n  expect(hash).not.toEqual(hashWithDifferentIterations);\n\n  expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentExtra);\n  expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentSaltAndExtra);\n  expect(hashWithDifferentExtra).not.toEqual(hashWithDifferentSaltAndExtra);\n});\n"],"mappings":"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"}
+{"version":3,"file":"crypto.js","names":["globalVar","HexclaveAssertionError","Result"],"sources":["../../src/utils/crypto.tsx"],"sourcesContent":["import { encodeBase32, encodeBase64 } from \"./bytes\";\nimport { HexclaveAssertionError } from \"./errors\";\nimport { globalVar } from \"./globals\";\nimport { Result } from \"./results\";\nimport { toArrayBufferBacked } from \"./typed-arrays\";\n\nexport function generateRandomValues(array: Uint8Array): typeof array {\n  if (!globalVar.crypto) {\n    throw new HexclaveAssertionError(\"Crypto API is not available in this environment. Are you using an old browser?\");\n  }\n  if (!globalVar.crypto.getRandomValues) {\n    throw new HexclaveAssertionError(\"crypto.getRandomValues is not available in this environment. Are you using an old browser?\");\n  }\n  return globalVar.crypto.getRandomValues(array);\n}\n\n/**\n * Generates a secure alphanumeric string using the system's cryptographically secure\n * random number generator.\n */\nexport function generateSecureRandomString(minBitsOfEntropy: number = 224) {\n  const base32CharactersCount = Math.ceil(minBitsOfEntropy / 5);\n  const bytesCount = Math.ceil(base32CharactersCount * 5 / 8);\n  const randomBytes = generateRandomValues(new Uint8Array(bytesCount));\n  const str = encodeBase32(randomBytes);\n  return str.slice(str.length - base32CharactersCount).toLowerCase();\n}\n\nasync function getDerivedSymmetricKey(purpose: string, secret: string | Uint8Array, salt: Uint8Array) {\n  const secretBytes = typeof secret === \"string\" ? new TextEncoder().encode(secret) : toArrayBufferBacked(secret);\n  const originalSecretKey = await crypto.subtle.importKey(\"raw\", secretBytes, \"HKDF\", false, [\"deriveKey\"]);\n  return await crypto.subtle.deriveKey(\n    {\n      name: \"HKDF\",\n      salt: toArrayBufferBacked(salt),\n      hash: \"SHA-256\",\n      // NOTE (Hexclave rebrand): do NOT rename this \"stack-*\" literal. It is a domain-separation\n      // tag baked into HKDF key derivation; changing it would derive different keys and make all\n      // previously-encrypted data undecryptable. It is an internal constant, never user-visible.\n      info: new TextEncoder().encode(JSON.stringify([\n        \"stack-crypto-helper-derived-symmetric-key\",\n        purpose,\n        typeof secret === \"string\" ? \"string-key\" : \"binary-key\",\n        encodeBase64(salt),\n      ])),\n    },\n    originalSecretKey,\n    { name: \"AES-GCM\", length: 256 },\n    false,\n    [\"encrypt\", \"decrypt\"]\n  );\n}\n\nexport async function encrypt({ purpose, secret, value }: { purpose: string, secret: string | Uint8Array, value: Uint8Array }) {\n  const iv = crypto.getRandomValues(new Uint8Array(12));\n  const salt = crypto.getRandomValues(new Uint8Array(16));\n  const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);\n\n  const cipher = await crypto.subtle.encrypt({\n    name: \"AES-GCM\",\n    iv,\n  }, derivedSecretKey, toArrayBufferBacked(value));\n\n  const version = [0x01, 0x00];\n  return new Uint8Array([...version, ...salt, ...iv, ...new Uint8Array(cipher)]);\n}\n\nexport async function decrypt({ purpose, secret, cipher }: { purpose: string, secret: string | Uint8Array, cipher: Uint8Array }) {\n  const version = cipher.slice(0, 2);\n  if (version[0] !== 0x01 || version[1] !== 0x00) throw new HexclaveAssertionError(\"Invalid ciphertext version in decrypt(...); expected 0x0100\", { purpose });\n  const salt = cipher.slice(2, 18);\n  const iv = cipher.slice(18, 30);\n  const cipherBytes = cipher.slice(30);\n  const derivedSecretKey = await getDerivedSymmetricKey(purpose, secret, salt);\n\n  try {\n    const plaintext = await crypto.subtle.decrypt({\n      name: \"AES-GCM\",\n      iv,\n    }, derivedSecretKey, cipherBytes);\n    return Result.ok(new Uint8Array(plaintext));\n  } catch (e) {\n    if (e instanceof DOMException && e.name === \"OperationError\") {\n      return Result.error(new Error(\"Invalid ciphertext or secret when decrypting encrypted value\", { cause: e }));\n    }\n    throw e;\n  }\n}\n\nimport.meta.vitest?.test(\"encrypt & decrypt\", async ({ expect }) => {\n  const encryptAndDecrypt = async (encryptPurpose: string, decryptPurpose: string, encryptSecret: string | Uint8Array, decryptSecret: string | Uint8Array, value: Uint8Array) => {\n    const encrypted = await encrypt({ purpose: encryptPurpose, secret: encryptSecret, value });\n    const decrypted = await decrypt({ purpose: decryptPurpose, secret: decryptSecret, cipher: encrypted });\n    return decrypted;\n  };\n\n  const exampleBytes = new TextEncoder().encode(\"hello\");\n\n  const exampleKey1 = crypto.getRandomValues(new Uint8Array(32));\n  const exampleKey2 = crypto.getRandomValues(new Uint8Array(32));\n\n  expect(await encryptAndDecrypt(\"p\", \"p\", \"secret\", \"secret\", exampleBytes)).toEqual(Result.ok(exampleBytes));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.ok(exampleBytes));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, \"secret\", exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n  expect(await encryptAndDecrypt(\"p\", \"p\", exampleKey1, exampleKey2, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n  expect(await encryptAndDecrypt(\"p\", \"not-p\", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: \"Invalid ciphertext or secret when decrypting encrypted value\" })));\n});\n\nexport type HashOptions = {\n  purpose: string,\n  salt?: string | Uint8Array,\n  extra?: string | Uint8Array,\n  value: string | Uint8Array,\n};\n\nexport async function hash(options: HashOptions) {\n  return await iteratedHash({ ...options, iterations: 1 });\n}\n\nexport async function iteratedHash(options: HashOptions & { iterations: number }) {\n  const stringOrUint8ArrayToUint8Array = (value: string | Uint8Array) => typeof value === \"string\" ? new TextEncoder().encode(value) : toArrayBufferBacked(value);\n  const stringOrUint8ArrayToBase64 = (value: string | Uint8Array) => encodeBase64(stringOrUint8ArrayToUint8Array(value));\n  const input = await crypto.subtle.importKey(\n    \"raw\",\n    stringOrUint8ArrayToUint8Array(options.value),\n    \"PBKDF2\",\n    false,\n    [\"deriveBits\"]\n  );\n  return new Uint8Array(await crypto.subtle.deriveBits({\n    name: \"PBKDF2\",\n    // NOTE (Hexclave rebrand): do NOT rename this \"stack-*\" literal. It is a domain-separation tag\n    // mixed into the PBKDF2 salt; changing it would change every hash output and break verification\n    // of all previously-hashed values. It is an internal constant, never user-visible.\n    salt: new TextEncoder().encode(JSON.stringify([\n      \"stack-crypto-helper-iterated-hash\",\n      options.purpose,\n      stringOrUint8ArrayToBase64(options.salt ?? \"\"),\n      stringOrUint8ArrayToBase64(options.extra ?? \"\"),\n    ])),\n    iterations: options.iterations,\n    hash: \"SHA-256\",\n  }, input, 256));\n}\n\nimport.meta.vitest?.test(\"iteratedHash\", async ({ expect }) => {\n  const valueBytes = new TextEncoder().encode(\"hello\");\n  const incrementBytes = new Uint8Array([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10]);\n\n  const hash = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_000 });\n  const hash2 = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_000 });\n  const hashWithDifferentPurpose = await iteratedHash({ purpose: \"different-purpose\", value: valueBytes, iterations: 100_000 });\n  const hashWithEmptySalt = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: new Uint8Array(0), iterations: 100_000 });\n  const hashWithDifferentSalt = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: incrementBytes, iterations: 100_000 });\n  const hashWithEmptyExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, extra: new Uint8Array(0), iterations: 100_000 });\n  const hashWithDifferentExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, extra: incrementBytes, iterations: 100_000 });\n  const hashWithDifferentValue = await iteratedHash({ purpose: \"purpose\", value: new TextEncoder().encode(\"hello2\"), iterations: 100_000 });\n  const hashWithDifferentSaltAndExtra = await iteratedHash({ purpose: \"purpose\", value: valueBytes, salt: incrementBytes, extra: incrementBytes, iterations: 100_000 });\n  const hashWithDifferentIterations = await iteratedHash({ purpose: \"purpose\", value: valueBytes, iterations: 100_001 });\n\n\n  expect(hash).toEqual(hash2);\n  expect(hash).not.toEqual(hashWithDifferentPurpose);\n  expect(hash).toEqual(hashWithEmptySalt);\n  expect(hash).not.toEqual(hashWithDifferentSalt);\n  expect(hash).toEqual(hashWithEmptyExtra);\n  expect(hash).not.toEqual(hashWithDifferentExtra);\n  expect(hash).not.toEqual(hashWithDifferentValue);\n  expect(hash).not.toEqual(hashWithDifferentIterations);\n\n  expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentExtra);\n  expect(hashWithDifferentSalt).not.toEqual(hashWithDifferentSaltAndExtra);\n  expect(hashWithDifferentExtra).not.toEqual(hashWithDifferentSaltAndExtra);\n});\n"],"mappings":"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"}

package/dist/utils/currencies.d.ts

@@ -1,4 +1,4 @@
-import { Currency, MoneyAmount, SUPPORTED_CURRENCIES } from "./currency-constants.js";
+import { n as MoneyAmount, r as SUPPORTED_CURRENCIES, t as Currency } from "../currency-constants-Cq_q8twn.js";
 
 //#region src/utils/currencies.d.ts
 type SupportedCurrency = (typeof SUPPORTED_CURRENCIES)[number];

package/dist/utils/currencies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"currencies.d.ts","names":[],"sources":["../../src/utils/currencies.tsx"],"mappings":";;;KAIY,iBAAA,WAA4B,oBAAA;AAAA,iBAExB,wBAAA,CAAyB,MAAA,EAAQ,WAAA,EAAa,QAAA,EAAU,QAAA"}
+{"version":3,"file":"currencies.d.ts","names":[],"sources":["../../src/utils/currencies.tsx"],"mappings":";;;KAIY,iBAAA,WAA4B,oBAAoB;AAAA,iBAE5C,wBAAA,CAAyB,MAAA,EAAQ,WAAA,EAAa,QAAA,EAAU,QAAQ"}

package/dist/utils/currencies.js

@@ -1,9 +1,7 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let ___schema_fields_js = require("../schema-fields.js");
 let __errors_js = require("./errors.js");
-let __currency_constants_js = require("./currency-constants.js");
-
+require("./currency-constants.js");
 //#region src/utils/currencies.tsx
 function moneyAmountToStripeUnits(amount, currency) {
 	const validated = (0, ___schema_fields_js.moneyAmountSchema)(currency).defined().validateSync(amount);
@@ -12,41 +10,7 @@ function moneyAmountToStripeUnits(amount, currency) {
 	const paddedFractional = fractional.padEnd(currency.decimals, "0");
 	return Number.parseInt(whole + paddedFractional, 10);
 }
-(void 0)?.describe("moneyAmountToStripeUnits", (test) => {
-	const USD = __currency_constants_js.SUPPORTED_CURRENCIES.find((c) => c.code === "USD");
-	test("converts fully-padded USD amounts", ({ expect }) => {
-		expect(moneyAmountToStripeUnits("5.00", USD)).toBe(500);
-		expect(moneyAmountToStripeUnits("0.01", USD)).toBe(1);
-		expect(moneyAmountToStripeUnits("12.34", USD)).toBe(1234);
-	});
-	test("converts whole-number USD amounts (no decimals)", ({ expect }) => {
-		expect(moneyAmountToStripeUnits("5", USD)).toBe(500);
-		expect(moneyAmountToStripeUnits("10", USD)).toBe(1e3);
-		expect(moneyAmountToStripeUnits("0", USD)).toBe(0);
-	});
-	test("converts USD amounts with one decimal digit", ({ expect }) => {
-		expect(moneyAmountToStripeUnits("5.5", USD)).toBe(550);
-		expect(moneyAmountToStripeUnits("0.5", USD)).toBe(50);
-	});
-	test("matches stripeUnitsToMoneyAmount round-trip", ({ expect }) => {
-		for (const cents of [
-			0,
-			1,
-			5,
-			50,
-			99,
-			100,
-			1234,
-			1e5
-		]) expect(moneyAmountToStripeUnits(`${Math.floor(cents / 100)}.${(cents % 100).toString().padStart(2, "0")}`, USD)).toBe(cents);
-	});
-	test("rejects invalid money strings via schema", ({ expect }) => {
-		expect(() => moneyAmountToStripeUnits("abc", USD)).toThrow();
-		expect(() => moneyAmountToStripeUnits("5.555", USD)).toThrow();
-		expect(() => moneyAmountToStripeUnits("05", USD)).toThrow();
-	});
-});
-
 //#endregion
 exports.moneyAmountToStripeUnits = moneyAmountToStripeUnits;
+
 //# sourceMappingURL=currencies.js.map