@hexclave/shared 1.0.41 → 1.0.43

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

@@ -60,33 +60,7 @@ 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
 export { CLOUD_HOST_PAIRS, getCloudApiUrlSiblings, getHexclaveApiBaseUrl, getStackAuthApiBaseUrl };
+
 //# sourceMappingURL=cloud-hosts.js.map

package/dist/esm/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/esm/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/esm/utils/compile-time.js

@@ -8,7 +8,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
 export { scrambleDuringCompileTime };
+
 //# sourceMappingURL=compile-time.js.map

package/dist/esm/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/esm/utils/country-codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"country-codes.d.ts","names":[],"sources":["../../../src/utils/country-codes.ts"],"mappings":";iBAAgB,oBAAA,CAAqB,WAAA;AAAA,iBAIrB,kBAAA,CAAmB,WAAA;;;;;iBASnB,mBAAA,CAAoB,KAAA"}
+{"version":3,"file":"country-codes.d.ts","names":[],"sources":["../../../src/utils/country-codes.ts"],"mappings":";iBAAgB,oBAAA,CAAqB,WAAmB;AAAA,iBAIxC,kBAAA,CAAmB,WAAmB;;;;AAJE;iBAaxC,mBAAA,CAAoB,KAAwB"}

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

@@ -15,22 +15,7 @@ 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
 export { isValidCountryCode, normalizeCountryCode, validateCountryCode };
+
 //# sourceMappingURL=country-codes.js.map

package/dist/esm/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/esm/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/esm/utils/crypto.js

@@ -3,7 +3,6 @@ import { HexclaveAssertionError } from "./errors.js";
 import { globalVar } from "./globals.js";
 import { Result } from "./results.js";
 import { toArrayBufferBacked } from "./typed-arrays.js";
-
 //#region src/utils/crypto.tsx
 function generateRandomValues(array) {
 	if (!globalVar.crypto) throw new HexclaveAssertionError("Crypto API is not available in this environment. Are you using an old browser?");
@@ -39,8 +38,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",
@@ -71,27 +70,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(Result.ok(exampleBytes));
-	expect(await encryptAndDecrypt("p", "p", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.ok(exampleBytes));
-	expect(await encryptAndDecrypt("p", "p", exampleKey1, "secret", exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
-	expect(await encryptAndDecrypt("p", "p", exampleKey1, exampleKey2, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
-	expect(await encryptAndDecrypt("p", "not-p", exampleKey1, exampleKey1, exampleBytes)).toEqual(Result.error(expect.objectContaining({ message: "Invalid ciphertext or secret when decrypting encrypted value" })));
-});
 async function hash(options) {
 	return await iteratedHash({
 		...options,
@@ -114,95 +92,7 @@ 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
 export { decrypt, encrypt, generateRandomValues, generateSecureRandomString, hash, iteratedHash };
+
 //# sourceMappingURL=crypto.js.map

package/dist/esm/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":[],"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/esm/utils/currencies.d.ts

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

package/dist/esm/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/esm/utils/currencies.js

@@ -1,7 +1,6 @@
 import { moneyAmountSchema } from "../schema-fields.js";
 import { HexclaveAssertionError } from "./errors.js";
-import { SUPPORTED_CURRENCIES } from "./currency-constants.js";
-
+import "./currency-constants.js";
 //#region src/utils/currencies.tsx
 function moneyAmountToStripeUnits(amount, currency) {
 	const validated = moneyAmountSchema(currency).defined().validateSync(amount);
@@ -10,41 +9,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 = 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
 export { moneyAmountToStripeUnits };
+
 //# sourceMappingURL=currencies.js.map

package/dist/esm/utils/currencies.js.map

@@ -1 +1 @@
-{"version":3,"file":"currencies.js","names":[],"sources":["../../../src/utils/currencies.tsx"],"sourcesContent":["import { moneyAmountSchema } from \"../schema-fields\";\nimport { SUPPORTED_CURRENCIES, type Currency, type MoneyAmount } from \"./currency-constants\";\nimport { HexclaveAssertionError } from \"./errors\";\n\nexport type SupportedCurrency = (typeof SUPPORTED_CURRENCIES)[number];\n\nexport function moneyAmountToStripeUnits(amount: MoneyAmount, currency: Currency): number {\n  const validated = moneyAmountSchema(currency).defined().validateSync(amount);\n  if (currency.stripeDecimals !== currency.decimals) {\n    throw new HexclaveAssertionError(\"unimplemented: TODO support different decimal configurations\");\n  }\n  // `moneyAmountSchema` accepts strings with 0..currency.decimals fractional\n  // digits, so we must right-pad the fractional part before stripping the dot.\n  // A naïve `replace('.', '')` underweights inputs like \"5\" → 5 (should be 500\n  // for USD) and \"0.5\" → 5 (should be 50).\n  const [whole, fractional = \"\"] = validated.split(\".\");\n  const paddedFractional = fractional.padEnd(currency.decimals, \"0\");\n  return Number.parseInt(whole + paddedFractional, 10);\n}\n\nimport.meta.vitest?.describe(\"moneyAmountToStripeUnits\", (test) => {\n  const USD = SUPPORTED_CURRENCIES.find((c) => c.code === \"USD\")!;\n\n  test(\"converts fully-padded USD amounts\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5.00\" as MoneyAmount, USD)).toBe(500);\n    expect(moneyAmountToStripeUnits(\"0.01\" as MoneyAmount, USD)).toBe(1);\n    expect(moneyAmountToStripeUnits(\"12.34\" as MoneyAmount, USD)).toBe(1234);\n  });\n\n  test(\"converts whole-number USD amounts (no decimals)\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5\" as MoneyAmount, USD)).toBe(500);\n    expect(moneyAmountToStripeUnits(\"10\" as MoneyAmount, USD)).toBe(1000);\n    expect(moneyAmountToStripeUnits(\"0\" as MoneyAmount, USD)).toBe(0);\n  });\n\n  test(\"converts USD amounts with one decimal digit\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5.5\" as MoneyAmount, USD)).toBe(550);\n    expect(moneyAmountToStripeUnits(\"0.5\" as MoneyAmount, USD)).toBe(50);\n  });\n\n  test(\"matches stripeUnitsToMoneyAmount round-trip\", ({ expect }) => {\n    for (const cents of [0, 1, 5, 50, 99, 100, 1234, 100000]) {\n      const padded = `${Math.floor(cents / 100)}.${(cents % 100).toString().padStart(2, \"0\")}` as MoneyAmount;\n      expect(moneyAmountToStripeUnits(padded, USD)).toBe(cents);\n    }\n  });\n\n  test(\"rejects invalid money strings via schema\", ({ expect }) => {\n    expect(() => moneyAmountToStripeUnits(\"abc\" as MoneyAmount, USD)).toThrow();\n    expect(() => moneyAmountToStripeUnits(\"5.555\" as MoneyAmount, USD)).toThrow();\n    expect(() => moneyAmountToStripeUnits(\"05\" as MoneyAmount, USD)).toThrow();\n  });\n});\n"],"mappings":";;;;;AAMA,SAAgB,yBAAyB,QAAqB,UAA4B;CACxF,MAAM,YAAY,kBAAkB,SAAS,CAAC,SAAS,CAAC,aAAa,OAAO;AAC5E,KAAI,SAAS,mBAAmB,SAAS,SACvC,OAAM,IAAI,uBAAuB,+DAA+D;CAMlG,MAAM,CAAC,OAAO,aAAa,MAAM,UAAU,MAAM,IAAI;CACrD,MAAM,mBAAmB,WAAW,OAAO,SAAS,UAAU,IAAI;AAClE,QAAO,OAAO,SAAS,QAAQ,kBAAkB,GAAG;;CAGtD,SAAW,SAAS,6BAAU,SAA4B;CACxD,MAAM,MAAM,qBAAqB,MAAM,MAAM,EAAE,SAAS,MAAM;AAE9D,MAAK,sCAAsC,EAAE,aAAa;AACxD,SAAO,yBAAyB,QAAuB,IAAI,CAAC,CAAC,KAAK,IAAI;AACtE,SAAO,yBAAyB,QAAuB,IAAI,CAAC,CAAC,KAAK,EAAE;AACpE,SAAO,yBAAyB,SAAwB,IAAI,CAAC,CAAC,KAAK,KAAK;GACxE;AAEF,MAAK,oDAAoD,EAAE,aAAa;AACtE,SAAO,yBAAyB,KAAoB,IAAI,CAAC,CAAC,KAAK,IAAI;AACnE,SAAO,yBAAyB,MAAqB,IAAI,CAAC,CAAC,KAAK,IAAK;AACrE,SAAO,yBAAyB,KAAoB,IAAI,CAAC,CAAC,KAAK,EAAE;GACjE;AAEF,MAAK,gDAAgD,EAAE,aAAa;AAClE,SAAO,yBAAyB,OAAsB,IAAI,CAAC,CAAC,KAAK,IAAI;AACrE,SAAO,yBAAyB,OAAsB,IAAI,CAAC,CAAC,KAAK,GAAG;GACpE;AAEF,MAAK,gDAAgD,EAAE,aAAa;AAClE,OAAK,MAAM,SAAS;GAAC;GAAG;GAAG;GAAG;GAAI;GAAI;GAAK;GAAM;GAAO,CAEtD,QAAO,yBADQ,GAAG,KAAK,MAAM,QAAQ,IAAI,CAAC,IAAI,QAAQ,KAAK,UAAU,CAAC,SAAS,GAAG,IAAI,IAC9C,IAAI,CAAC,CAAC,KAAK,MAAM;GAE3D;AAEF,MAAK,6CAA6C,EAAE,aAAa;AAC/D,eAAa,yBAAyB,OAAsB,IAAI,CAAC,CAAC,SAAS;AAC3E,eAAa,yBAAyB,SAAwB,IAAI,CAAC,CAAC,SAAS;AAC7E,eAAa,yBAAyB,MAAqB,IAAI,CAAC,CAAC,SAAS;GAC1E;EACF"}
+{"version":3,"file":"currencies.js","names":[],"sources":["../../../src/utils/currencies.tsx"],"sourcesContent":["import { moneyAmountSchema } from \"../schema-fields\";\nimport { SUPPORTED_CURRENCIES, type Currency, type MoneyAmount } from \"./currency-constants\";\nimport { HexclaveAssertionError } from \"./errors\";\n\nexport type SupportedCurrency = (typeof SUPPORTED_CURRENCIES)[number];\n\nexport function moneyAmountToStripeUnits(amount: MoneyAmount, currency: Currency): number {\n  const validated = moneyAmountSchema(currency).defined().validateSync(amount);\n  if (currency.stripeDecimals !== currency.decimals) {\n    throw new HexclaveAssertionError(\"unimplemented: TODO support different decimal configurations\");\n  }\n  // `moneyAmountSchema` accepts strings with 0..currency.decimals fractional\n  // digits, so we must right-pad the fractional part before stripping the dot.\n  // A naïve `replace('.', '')` underweights inputs like \"5\" → 5 (should be 500\n  // for USD) and \"0.5\" → 5 (should be 50).\n  const [whole, fractional = \"\"] = validated.split(\".\");\n  const paddedFractional = fractional.padEnd(currency.decimals, \"0\");\n  return Number.parseInt(whole + paddedFractional, 10);\n}\n\nimport.meta.vitest?.describe(\"moneyAmountToStripeUnits\", (test) => {\n  const USD = SUPPORTED_CURRENCIES.find((c) => c.code === \"USD\")!;\n\n  test(\"converts fully-padded USD amounts\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5.00\" as MoneyAmount, USD)).toBe(500);\n    expect(moneyAmountToStripeUnits(\"0.01\" as MoneyAmount, USD)).toBe(1);\n    expect(moneyAmountToStripeUnits(\"12.34\" as MoneyAmount, USD)).toBe(1234);\n  });\n\n  test(\"converts whole-number USD amounts (no decimals)\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5\" as MoneyAmount, USD)).toBe(500);\n    expect(moneyAmountToStripeUnits(\"10\" as MoneyAmount, USD)).toBe(1000);\n    expect(moneyAmountToStripeUnits(\"0\" as MoneyAmount, USD)).toBe(0);\n  });\n\n  test(\"converts USD amounts with one decimal digit\", ({ expect }) => {\n    expect(moneyAmountToStripeUnits(\"5.5\" as MoneyAmount, USD)).toBe(550);\n    expect(moneyAmountToStripeUnits(\"0.5\" as MoneyAmount, USD)).toBe(50);\n  });\n\n  test(\"matches stripeUnitsToMoneyAmount round-trip\", ({ expect }) => {\n    for (const cents of [0, 1, 5, 50, 99, 100, 1234, 100000]) {\n      const padded = `${Math.floor(cents / 100)}.${(cents % 100).toString().padStart(2, \"0\")}` as MoneyAmount;\n      expect(moneyAmountToStripeUnits(padded, USD)).toBe(cents);\n    }\n  });\n\n  test(\"rejects invalid money strings via schema\", ({ expect }) => {\n    expect(() => moneyAmountToStripeUnits(\"abc\" as MoneyAmount, USD)).toThrow();\n    expect(() => moneyAmountToStripeUnits(\"5.555\" as MoneyAmount, USD)).toThrow();\n    expect(() => moneyAmountToStripeUnits(\"05\" as MoneyAmount, USD)).toThrow();\n  });\n});\n"],"mappings":";;;;AAMA,SAAgB,yBAAyB,QAAqB,UAA4B;CACxF,MAAM,YAAY,kBAAkB,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,aAAa,MAAM;CAC3E,IAAI,SAAS,mBAAmB,SAAS,UACvC,MAAM,IAAI,uBAAuB,8DAA8D;CAMjG,MAAM,CAAC,OAAO,aAAa,MAAM,UAAU,MAAM,GAAG;CACpD,MAAM,mBAAmB,WAAW,OAAO,SAAS,UAAU,GAAG;CACjE,OAAO,OAAO,SAAS,QAAQ,kBAAkB,EAAE;AACrD"}

package/dist/esm/utils/currency-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"currency-constants.d.ts","names":[],"sources":["../../../src/utils/currency-constants.tsx"],"mappings":";;AAMA;;;;;KAAY,WAAA;AAAA,KAEA,QAAA;EACV,IAAA,EAAM,SAAA;EACN,QAAA;EACA,cAAA;AAAA;AAAA,cAGW,oBAAA;EAAA"}
+{"version":3,"file":"currency-constants.d.ts","names":[],"sources":["../../../src/utils/currency-constants.tsx"],"mappings":";;AAMA;;;;AAAuB;KAAX,WAAA;AAAA,KAEA,QAAA;EACV,IAAA,EAAM,SAAS;EACf,QAAA;EACA,cAAA;AAAA;AAAA,cAGW,oBAAA;EAAA"}

package/dist/esm/utils/currency-constants.js

@@ -36,7 +36,7 @@ const SUPPORTED_CURRENCIES = [
 		stripeDecimals: 2
 	}
 ];
-
 //#endregion
 export { SUPPORTED_CURRENCIES };
+
 //# sourceMappingURL=currency-constants.js.map

package/dist/esm/utils/currency-constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"currency-constants.js","names":[],"sources":["../../../src/utils/currency-constants.tsx"],"sourcesContent":["/**\n * A decimal string representing a monetary amount, e.g. `\"9.99\"`, `\"0.01\"`, or `\"1000\"`.\n *\n * This is NOT an integer in cents/minor units — it is always a human-readable decimal string.\n * For example, nine dollars and ninety-nine cents is `\"9.99\"`, not `999`.\n */\nexport type MoneyAmount = `${number}` | `${number}.${number}`;\n\nexport type Currency = {\n  code: Uppercase<string>,\n  decimals: number,\n  stripeDecimals: number,\n};\n\nexport const SUPPORTED_CURRENCIES = [\n  {\n    code: 'USD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'EUR',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'GBP',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'JPY',\n    decimals: 0,\n    stripeDecimals: 0,\n  },\n  {\n    code: 'INR',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'AUD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'CAD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n] as const satisfies Currency[];\n"],"mappings":";AAcA,MAAa,uBAAuB;CAClC;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACD;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;EACjB;CACF"}
+{"version":3,"file":"currency-constants.js","names":[],"sources":["../../../src/utils/currency-constants.tsx"],"sourcesContent":["/**\n * A decimal string representing a monetary amount, e.g. `\"9.99\"`, `\"0.01\"`, or `\"1000\"`.\n *\n * This is NOT an integer in cents/minor units — it is always a human-readable decimal string.\n * For example, nine dollars and ninety-nine cents is `\"9.99\"`, not `999`.\n */\nexport type MoneyAmount = `${number}` | `${number}.${number}`;\n\nexport type Currency = {\n  code: Uppercase<string>,\n  decimals: number,\n  stripeDecimals: number,\n};\n\nexport const SUPPORTED_CURRENCIES = [\n  {\n    code: 'USD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'EUR',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'GBP',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'JPY',\n    decimals: 0,\n    stripeDecimals: 0,\n  },\n  {\n    code: 'INR',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'AUD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n  {\n    code: 'CAD',\n    decimals: 2,\n    stripeDecimals: 2,\n  },\n] as const satisfies Currency[];\n"],"mappings":";AAcA,MAAa,uBAAuB;CAClC;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;CAClB;CACA;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;CAClB;CACA;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;CAClB;CACA;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;CAClB;CACA;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;CAClB;CACA;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;CAClB;CACA;EACE,MAAM;EACN,UAAU;EACV,gBAAgB;CAClB;AACF"}

package/dist/esm/utils/dates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dates.d.ts","names":[],"sources":["../../../src/utils/dates.tsx"],"mappings":";iBAIgB,SAAA,CAAU,IAAA,EAAM,IAAA;AAAA,iBAuBhB,OAAA,CAAQ,IAAA,EAAM,IAAA;AAAA,iBAiCd,eAAA,CAAgB,IAAA,EAAM,IAAA;EACpC,MAAA;EAzD8B;;AAuBhC;EAsCE,kBAAA;AAAA;;;AALF;iBAkDgB,2BAAA,CAA4B,IAAA,EAAM,IAAA;AAAA,KAkCtC,QAAA;AAAA,KACA,WAAA;AAAA,iBA+CI,gBAAA,CAAiB,IAAA,EAAM,IAAA,EAAM,QAAA,EAAU,QAAA,GAAW,IAAA;AAAA,iBAIlD,WAAA,CAAY,IAAA,EAAM,IAAA,EAAM,QAAA,EAAU,QAAA,GAAW,IAAA;AAAA,cAIhD,eAAA,EAAe,IAAA;AAAA,iBAUZ,mBAAA,CAAoB,MAAA,EAAQ,IAAA,EAAM,EAAA,EAAI,IAAA,EAAM,MAAA,EAAQ,WAAA"}
+{"version":3,"file":"dates.d.ts","names":[],"sources":["../../../src/utils/dates.tsx"],"mappings":";iBAIgB,SAAA,CAAU,IAAU,EAAJ,IAAI;AAAA,iBAuBpB,OAAA,CAAQ,IAAU,EAAJ,IAAI;AAAA,iBAiClB,eAAA,CAAgB,IAAA,EAAM,IAAI;EACxC,MAAA;EAzD8B;AAAI;AAuBpC;EAsCE,kBAAA;AAAA;;AAtCgC;AAiClC;iBAkDgB,2BAAA,CAA4B,IAAU,EAAJ,IAAI;AAAA,KAkC1C,QAAA;AAAA,KACA,WAAA;AAAA,iBA+CI,gBAAA,CAAiB,IAAA,EAAM,IAAA,EAAM,QAAA,EAAU,QAAA,GAAW,IAAA;AAAA,iBAIlD,WAAA,CAAY,IAAA,EAAM,IAAA,EAAM,QAAA,EAAU,QAAA,GAAW,IAAA;AAAA,cAIhD,eAAA,EAAe,IAA6B;AAAA,iBAUzC,mBAAA,CAAoB,MAAA,EAAQ,IAAA,EAAM,EAAA,EAAI,IAAA,EAAM,MAAA,EAAQ,WAAA"}

package/dist/esm/utils/dates.js

@@ -1,17 +1,10 @@
 import { intervalSchema } from "../schema-fields.js";
 import { HexclaveAssertionError } from "./errors.js";
 import { remainder } from "./math.js";
-
 //#region src/utils/dates.tsx
 function isWeekend(date) {
 	return date.getDay() === 0 || date.getDay() === 6;
 }
-(void 0)?.test("isWeekend", ({ expect }) => {
-	expect(isWeekend(new Date(2023, 0, 1))).toBe(true);
-	expect(isWeekend(new Date(2023, 0, 7))).toBe(true);
-	expect(isWeekend(new Date(2023, 0, 2))).toBe(false);
-	expect(isWeekend(new Date(2023, 0, 6))).toBe(false);
-});
 const agoUnits = [
 	[60, "second"],
 	[60, "minute"],
@@ -22,23 +15,6 @@ const agoUnits = [
 function fromNow(date) {
 	return fromNowDetailed(date).result;
 }
-(void 0)?.test("fromNow", ({ expect }) => {
-	const fixedDate = /* @__PURE__ */ new Date("2023-01-15T12:00:00.000Z");
-	(void 0)?.vi.useFakeTimers();
-	(void 0)?.vi.setSystemTime(fixedDate);
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T11:59:50.000Z"))).toBe("just now");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T11:59:00.000Z"))).toBe("1 minute ago");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T11:00:00.000Z"))).toBe("1 hour ago");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-14T12:00:00.000Z"))).toBe("1 day ago");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-08T12:00:00.000Z"))).toBe("1 week ago");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T12:00:10.000Z"))).toBe("just now");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T12:01:00.000Z"))).toBe("in 1 minute");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-15T13:00:00.000Z"))).toBe("in 1 hour");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-16T12:00:00.000Z"))).toBe("in 1 day");
-	expect(fromNow(/* @__PURE__ */ new Date("2023-01-22T12:00:00.000Z"))).toBe("in 1 week");
-	expect(fromNow(/* @__PURE__ */ new Date("2022-01-15T12:00:00.000Z"))).toMatch(/Jan 15, 2022/);
-	(void 0)?.vi.useRealTimers();
-});
 function fromNowDetailed(date) {
 	if (!(date instanceof Date)) throw new Error(`fromNow only accepts Date objects (received: ${date})`);
 	const elapsed = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
@@ -78,17 +54,6 @@ function getInputDatetimeLocalString(date) {
 	date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
 	return date.toISOString().slice(0, 19);
 }
-(void 0)?.test("getInputDatetimeLocalString", ({ expect }) => {
-	(void 0)?.vi.useFakeTimers();
-	expect(getInputDatetimeLocalString(/* @__PURE__ */ new Date("2023-01-15T12:30:45.000Z"))).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
-	const dates = [
-		/* @__PURE__ */ new Date("2023-01-01T00:00:00.000Z"),
-		/* @__PURE__ */ new Date("2023-06-15T23:59:59.000Z"),
-		/* @__PURE__ */ new Date("2023-12-31T12:34:56.000Z")
-	];
-	for (const date of dates) expect(getInputDatetimeLocalString(date)).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
-	(void 0)?.vi.useRealTimers();
-});
 function applyInterval(date, times, interval) {
 	if (!intervalSchema.isValidSync(interval)) throw new HexclaveAssertionError(`Invalid interval`, { interval });
 	const [amount, unit] = interval;
@@ -153,15 +118,7 @@ function getIntervalsElapsed(anchor, to, repeat) {
 	}
 	return 0;
 }
-(void 0)?.test("getIntervalsElapsed", ({ expect }) => {
-	const anchor = /* @__PURE__ */ new Date("2025-01-01T00:00:00.000Z");
-	const to = /* @__PURE__ */ new Date("2025-01-15T00:00:00.000Z");
-	expect(getIntervalsElapsed(anchor, to, [1, "week"])).toBe(2);
-	expect(getIntervalsElapsed(anchor, to, [3, "day"])).toBe(4);
-	expect(getIntervalsElapsed(/* @__PURE__ */ new Date("2023-01-31T00:00:00.000Z"), /* @__PURE__ */ new Date("2023-03-01T00:00:00.000Z"), [1, "month"])).toBe(0);
-	expect(getIntervalsElapsed(/* @__PURE__ */ new Date("2020-01-01T00:00:00.000Z"), /* @__PURE__ */ new Date("2022-06-01T00:00:00.000Z"), [1, "year"])).toBe(2);
-});
-
 //#endregion
 export { FAR_FUTURE_DATE, addInterval, fromNow, fromNowDetailed, getInputDatetimeLocalString, getIntervalsElapsed, isWeekend, subtractInterval };
+
 //# sourceMappingURL=dates.js.map

package/dist/esm/utils/dates.js.map

@@ -1 +1 @@
-{"version":3,"file":"dates.js","names":[],"sources":["../../../src/utils/dates.tsx"],"sourcesContent":["import { intervalSchema } from \"../schema-fields\";\nimport { HexclaveAssertionError } from \"./errors\";\nimport { remainder } from \"./math\";\n\nexport function isWeekend(date: Date): boolean {\n  return date.getDay() === 0 || date.getDay() === 6;\n}\n\nimport.meta.vitest?.test(\"isWeekend\", ({ expect }) => {\n  // Sunday (day 0)\n  expect(isWeekend(new Date(2023, 0, 1))).toBe(true);\n  // Saturday (day 6)\n  expect(isWeekend(new Date(2023, 0, 7))).toBe(true);\n  // Monday (day 1)\n  expect(isWeekend(new Date(2023, 0, 2))).toBe(false);\n  // Friday (day 5)\n  expect(isWeekend(new Date(2023, 0, 6))).toBe(false);\n});\n\nconst agoUnits = [\n  [60, 'second'],\n  [60, 'minute'],\n  [24, 'hour'],\n  [7, 'day'],\n  [5, 'week'],\n] as const;\n\nexport function fromNow(date: Date): string {\n  return fromNowDetailed(date).result;\n}\n\nimport.meta.vitest?.test(\"fromNow\", ({ expect }) => {\n  // Set a fixed date for testing\n  const fixedDate = new Date(\"2023-01-15T12:00:00.000Z\");\n\n  // Use Vitest's fake timers\n  import.meta.vitest?.vi.useFakeTimers();\n  import.meta.vitest?.vi.setSystemTime(fixedDate);\n\n  // Test past times\n  expect(fromNow(new Date(\"2023-01-15T11:59:50.000Z\"))).toBe(\"just now\");\n  expect(fromNow(new Date(\"2023-01-15T11:59:00.000Z\"))).toBe(\"1 minute ago\");\n  expect(fromNow(new Date(\"2023-01-15T11:00:00.000Z\"))).toBe(\"1 hour ago\");\n  expect(fromNow(new Date(\"2023-01-14T12:00:00.000Z\"))).toBe(\"1 day ago\");\n  expect(fromNow(new Date(\"2023-01-08T12:00:00.000Z\"))).toBe(\"1 week ago\");\n\n  // Test future times\n  expect(fromNow(new Date(\"2023-01-15T12:00:10.000Z\"))).toBe(\"just now\");\n  expect(fromNow(new Date(\"2023-01-15T12:01:00.000Z\"))).toBe(\"in 1 minute\");\n  expect(fromNow(new Date(\"2023-01-15T13:00:00.000Z\"))).toBe(\"in 1 hour\");\n  expect(fromNow(new Date(\"2023-01-16T12:00:00.000Z\"))).toBe(\"in 1 day\");\n  expect(fromNow(new Date(\"2023-01-22T12:00:00.000Z\"))).toBe(\"in 1 week\");\n\n  // Test very old dates (should use date format)\n  expect(fromNow(new Date(\"2022-01-15T12:00:00.000Z\"))).toMatch(/Jan 15, 2022/);\n\n  // Restore real timers\n  import.meta.vitest?.vi.useRealTimers();\n});\n\nexport function fromNowDetailed(date: Date): {\n  result: string,\n  /**\n   * May be Infinity if the result will never change.\n   */\n  secondsUntilChange: number,\n} {\n  if (!(date instanceof Date)) {\n    throw new Error(`fromNow only accepts Date objects (received: ${date})`);\n  }\n\n  const now = new Date();\n  const elapsed = now.getTime() - date.getTime();\n\n  let remainingInUnit = Math.abs(elapsed) / 1000;\n  if (remainingInUnit < 15) {\n    return {\n      result: 'just now',\n      secondsUntilChange: 15 - remainingInUnit,\n    };\n  }\n  let unitInSeconds = 1;\n  for (const [nextUnitSize, unitName] of agoUnits) {\n    const rounded = Math.round(remainingInUnit);\n    if (rounded < nextUnitSize) {\n      if (elapsed < 0) {\n        return {\n          result: `in ${rounded} ${unitName}${rounded === 1 ? '' : 's'}`,\n          secondsUntilChange: remainder((remainingInUnit - rounded + 0.5) * unitInSeconds, unitInSeconds),\n        };\n      } else {\n        return {\n          result: `${rounded} ${unitName}${rounded === 1 ? '' : 's'} ago`,\n          secondsUntilChange: remainder((rounded - remainingInUnit - 0.5) * unitInSeconds, unitInSeconds),\n        };\n      }\n    }\n    unitInSeconds *= nextUnitSize;\n    remainingInUnit /= nextUnitSize;\n  }\n\n  return {\n    result: date.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' }),\n    secondsUntilChange: Infinity,\n  };\n}\n\n/**\n * Returns a string representation of the given date in the format expected by the `datetime-local` input type.\n */\nexport function getInputDatetimeLocalString(date: Date): string {\n  date = new Date(date);\n  date.setMinutes(date.getMinutes() - date.getTimezoneOffset());\n  return date.toISOString().slice(0, 19);\n}\n\nimport.meta.vitest?.test(\"getInputDatetimeLocalString\", ({ expect }) => {\n  // Use Vitest's fake timers to ensure consistent timezone behavior\n  import.meta.vitest?.vi.useFakeTimers();\n\n  // Test with a specific date\n  const mockDate = new Date(\"2023-01-15T12:30:45.000Z\");\n  const result = getInputDatetimeLocalString(mockDate);\n\n  // The result should be in the format YYYY-MM-DDTHH:MM:SS\n  expect(result).toMatch(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}$/);\n\n  // Test with different dates\n  const dates = [\n    new Date(\"2023-01-01T00:00:00.000Z\"),\n    new Date(\"2023-06-15T23:59:59.000Z\"),\n    new Date(\"2023-12-31T12:34:56.000Z\"),\n  ];\n\n  for (const date of dates) {\n    const result = getInputDatetimeLocalString(date);\n    expect(result).toMatch(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}$/);\n  }\n\n  // Restore real timers\n  import.meta.vitest?.vi.useRealTimers();\n});\n\n\nexport type Interval = [number, 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'];\nexport type DayInterval = [number, 'day' | 'week' | 'month' | 'year'];\n\nfunction applyInterval(date: Date, times: number, interval: Interval): Date {\n  if (!intervalSchema.isValidSync(interval)) {\n    throw new HexclaveAssertionError(`Invalid interval`, { interval });\n  }\n  const [amount, unit] = interval;\n  switch (unit) {\n    case 'millisecond': {\n      date.setMilliseconds(date.getMilliseconds() + amount * times);\n      break;\n    }\n    case 'second': {\n      date.setSeconds(date.getSeconds() + amount * times);\n      break;\n    }\n    case 'minute': {\n      date.setMinutes(date.getMinutes() + amount * times);\n      break;\n    }\n    case 'hour': {\n      date.setHours(date.getHours() + amount * times);\n      break;\n    }\n    case 'day': {\n      date.setDate(date.getDate() + amount * times);\n      break;\n    }\n    case 'week': {\n      date.setDate(date.getDate() + amount * times * 7);\n      break;\n    }\n    case 'month': {\n      date.setMonth(date.getMonth() + amount * times);\n      break;\n    }\n    case 'year': {\n      date.setFullYear(date.getFullYear() + amount * times);\n      break;\n    }\n    default: {\n      throw new HexclaveAssertionError(`Invalid interval despite schema validation`, { interval });\n    }\n  }\n  return date;\n}\n\nexport function subtractInterval(date: Date, interval: Interval): Date {\n  return applyInterval(date, -1, interval);\n}\n\nexport function addInterval(date: Date, interval: Interval): Date {\n  return applyInterval(date, 1, interval);\n}\n\nexport const FAR_FUTURE_DATE = new Date(8640000000000000); // 13 Sep 275760 00:00:00 UTC\n\nfunction getMsPerDayIntervalUnit(unit: 'day' | 'week'): number {\n  if (unit === 'day') {\n    return 24 * 60 * 60 * 1000;\n  }\n  return 7 * 24 * 60 * 60 * 1000;\n}\n\n\nexport function getIntervalsElapsed(anchor: Date, to: Date, repeat: DayInterval): number {\n  const [amount, unit] = repeat;\n  if (to <= anchor) return 0;\n  if (unit === 'day' || unit === 'week') {\n    const msPerUnit = getMsPerDayIntervalUnit(unit);\n    const diffMs = to.getTime() - anchor.getTime();\n    return Math.floor(diffMs / (msPerUnit * amount));\n  }\n  if ([\"month\", \"year\"].includes(unit)) {\n    let count = 0;\n    let current = new Date(anchor);\n    for (; ;) {\n      const next = addInterval(new Date(current), [amount, unit]);\n      if (next > to) break;\n      current = next;\n      count += 1;\n    }\n    return count;\n  }\n  return 0;\n}\n\nimport.meta.vitest?.test(\"getIntervalsElapsed\", ({ expect }) => {\n  const anchor = new Date('2025-01-01T00:00:00.000Z');\n  const to = new Date('2025-01-15T00:00:00.000Z');\n  expect(getIntervalsElapsed(anchor, to, [1, 'week'])).toBe(2);\n  expect(getIntervalsElapsed(anchor, to, [3, 'day'])).toBe(4);\n\n  const mAnchor = new Date('2023-01-31T00:00:00.000Z');\n  const mTo = new Date('2023-03-01T00:00:00.000Z');\n  expect(getIntervalsElapsed(mAnchor, mTo, [1, 'month'])).toBe(0);\n\n  const yAnchor = new Date('2020-01-01T00:00:00.000Z');\n  const yTo = new Date('2022-06-01T00:00:00.000Z');\n  expect(getIntervalsElapsed(yAnchor, yTo, [1, 'year'])).toBe(2);\n});\n"],"mappings":"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"}
+{"version":3,"file":"dates.js","names":[],"sources":["../../../src/utils/dates.tsx"],"sourcesContent":["import { intervalSchema } from \"../schema-fields\";\nimport { HexclaveAssertionError } from \"./errors\";\nimport { remainder } from \"./math\";\n\nexport function isWeekend(date: Date): boolean {\n  return date.getDay() === 0 || date.getDay() === 6;\n}\n\nimport.meta.vitest?.test(\"isWeekend\", ({ expect }) => {\n  // Sunday (day 0)\n  expect(isWeekend(new Date(2023, 0, 1))).toBe(true);\n  // Saturday (day 6)\n  expect(isWeekend(new Date(2023, 0, 7))).toBe(true);\n  // Monday (day 1)\n  expect(isWeekend(new Date(2023, 0, 2))).toBe(false);\n  // Friday (day 5)\n  expect(isWeekend(new Date(2023, 0, 6))).toBe(false);\n});\n\nconst agoUnits = [\n  [60, 'second'],\n  [60, 'minute'],\n  [24, 'hour'],\n  [7, 'day'],\n  [5, 'week'],\n] as const;\n\nexport function fromNow(date: Date): string {\n  return fromNowDetailed(date).result;\n}\n\nimport.meta.vitest?.test(\"fromNow\", ({ expect }) => {\n  // Set a fixed date for testing\n  const fixedDate = new Date(\"2023-01-15T12:00:00.000Z\");\n\n  // Use Vitest's fake timers\n  import.meta.vitest?.vi.useFakeTimers();\n  import.meta.vitest?.vi.setSystemTime(fixedDate);\n\n  // Test past times\n  expect(fromNow(new Date(\"2023-01-15T11:59:50.000Z\"))).toBe(\"just now\");\n  expect(fromNow(new Date(\"2023-01-15T11:59:00.000Z\"))).toBe(\"1 minute ago\");\n  expect(fromNow(new Date(\"2023-01-15T11:00:00.000Z\"))).toBe(\"1 hour ago\");\n  expect(fromNow(new Date(\"2023-01-14T12:00:00.000Z\"))).toBe(\"1 day ago\");\n  expect(fromNow(new Date(\"2023-01-08T12:00:00.000Z\"))).toBe(\"1 week ago\");\n\n  // Test future times\n  expect(fromNow(new Date(\"2023-01-15T12:00:10.000Z\"))).toBe(\"just now\");\n  expect(fromNow(new Date(\"2023-01-15T12:01:00.000Z\"))).toBe(\"in 1 minute\");\n  expect(fromNow(new Date(\"2023-01-15T13:00:00.000Z\"))).toBe(\"in 1 hour\");\n  expect(fromNow(new Date(\"2023-01-16T12:00:00.000Z\"))).toBe(\"in 1 day\");\n  expect(fromNow(new Date(\"2023-01-22T12:00:00.000Z\"))).toBe(\"in 1 week\");\n\n  // Test very old dates (should use date format)\n  expect(fromNow(new Date(\"2022-01-15T12:00:00.000Z\"))).toMatch(/Jan 15, 2022/);\n\n  // Restore real timers\n  import.meta.vitest?.vi.useRealTimers();\n});\n\nexport function fromNowDetailed(date: Date): {\n  result: string,\n  /**\n   * May be Infinity if the result will never change.\n   */\n  secondsUntilChange: number,\n} {\n  if (!(date instanceof Date)) {\n    throw new Error(`fromNow only accepts Date objects (received: ${date})`);\n  }\n\n  const now = new Date();\n  const elapsed = now.getTime() - date.getTime();\n\n  let remainingInUnit = Math.abs(elapsed) / 1000;\n  if (remainingInUnit < 15) {\n    return {\n      result: 'just now',\n      secondsUntilChange: 15 - remainingInUnit,\n    };\n  }\n  let unitInSeconds = 1;\n  for (const [nextUnitSize, unitName] of agoUnits) {\n    const rounded = Math.round(remainingInUnit);\n    if (rounded < nextUnitSize) {\n      if (elapsed < 0) {\n        return {\n          result: `in ${rounded} ${unitName}${rounded === 1 ? '' : 's'}`,\n          secondsUntilChange: remainder((remainingInUnit - rounded + 0.5) * unitInSeconds, unitInSeconds),\n        };\n      } else {\n        return {\n          result: `${rounded} ${unitName}${rounded === 1 ? '' : 's'} ago`,\n          secondsUntilChange: remainder((rounded - remainingInUnit - 0.5) * unitInSeconds, unitInSeconds),\n        };\n      }\n    }\n    unitInSeconds *= nextUnitSize;\n    remainingInUnit /= nextUnitSize;\n  }\n\n  return {\n    result: date.toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' }),\n    secondsUntilChange: Infinity,\n  };\n}\n\n/**\n * Returns a string representation of the given date in the format expected by the `datetime-local` input type.\n */\nexport function getInputDatetimeLocalString(date: Date): string {\n  date = new Date(date);\n  date.setMinutes(date.getMinutes() - date.getTimezoneOffset());\n  return date.toISOString().slice(0, 19);\n}\n\nimport.meta.vitest?.test(\"getInputDatetimeLocalString\", ({ expect }) => {\n  // Use Vitest's fake timers to ensure consistent timezone behavior\n  import.meta.vitest?.vi.useFakeTimers();\n\n  // Test with a specific date\n  const mockDate = new Date(\"2023-01-15T12:30:45.000Z\");\n  const result = getInputDatetimeLocalString(mockDate);\n\n  // The result should be in the format YYYY-MM-DDTHH:MM:SS\n  expect(result).toMatch(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}$/);\n\n  // Test with different dates\n  const dates = [\n    new Date(\"2023-01-01T00:00:00.000Z\"),\n    new Date(\"2023-06-15T23:59:59.000Z\"),\n    new Date(\"2023-12-31T12:34:56.000Z\"),\n  ];\n\n  for (const date of dates) {\n    const result = getInputDatetimeLocalString(date);\n    expect(result).toMatch(/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}$/);\n  }\n\n  // Restore real timers\n  import.meta.vitest?.vi.useRealTimers();\n});\n\n\nexport type Interval = [number, 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year'];\nexport type DayInterval = [number, 'day' | 'week' | 'month' | 'year'];\n\nfunction applyInterval(date: Date, times: number, interval: Interval): Date {\n  if (!intervalSchema.isValidSync(interval)) {\n    throw new HexclaveAssertionError(`Invalid interval`, { interval });\n  }\n  const [amount, unit] = interval;\n  switch (unit) {\n    case 'millisecond': {\n      date.setMilliseconds(date.getMilliseconds() + amount * times);\n      break;\n    }\n    case 'second': {\n      date.setSeconds(date.getSeconds() + amount * times);\n      break;\n    }\n    case 'minute': {\n      date.setMinutes(date.getMinutes() + amount * times);\n      break;\n    }\n    case 'hour': {\n      date.setHours(date.getHours() + amount * times);\n      break;\n    }\n    case 'day': {\n      date.setDate(date.getDate() + amount * times);\n      break;\n    }\n    case 'week': {\n      date.setDate(date.getDate() + amount * times * 7);\n      break;\n    }\n    case 'month': {\n      date.setMonth(date.getMonth() + amount * times);\n      break;\n    }\n    case 'year': {\n      date.setFullYear(date.getFullYear() + amount * times);\n      break;\n    }\n    default: {\n      throw new HexclaveAssertionError(`Invalid interval despite schema validation`, { interval });\n    }\n  }\n  return date;\n}\n\nexport function subtractInterval(date: Date, interval: Interval): Date {\n  return applyInterval(date, -1, interval);\n}\n\nexport function addInterval(date: Date, interval: Interval): Date {\n  return applyInterval(date, 1, interval);\n}\n\nexport const FAR_FUTURE_DATE = new Date(8640000000000000); // 13 Sep 275760 00:00:00 UTC\n\nfunction getMsPerDayIntervalUnit(unit: 'day' | 'week'): number {\n  if (unit === 'day') {\n    return 24 * 60 * 60 * 1000;\n  }\n  return 7 * 24 * 60 * 60 * 1000;\n}\n\n\nexport function getIntervalsElapsed(anchor: Date, to: Date, repeat: DayInterval): number {\n  const [amount, unit] = repeat;\n  if (to <= anchor) return 0;\n  if (unit === 'day' || unit === 'week') {\n    const msPerUnit = getMsPerDayIntervalUnit(unit);\n    const diffMs = to.getTime() - anchor.getTime();\n    return Math.floor(diffMs / (msPerUnit * amount));\n  }\n  if ([\"month\", \"year\"].includes(unit)) {\n    let count = 0;\n    let current = new Date(anchor);\n    for (; ;) {\n      const next = addInterval(new Date(current), [amount, unit]);\n      if (next > to) break;\n      current = next;\n      count += 1;\n    }\n    return count;\n  }\n  return 0;\n}\n\nimport.meta.vitest?.test(\"getIntervalsElapsed\", ({ expect }) => {\n  const anchor = new Date('2025-01-01T00:00:00.000Z');\n  const to = new Date('2025-01-15T00:00:00.000Z');\n  expect(getIntervalsElapsed(anchor, to, [1, 'week'])).toBe(2);\n  expect(getIntervalsElapsed(anchor, to, [3, 'day'])).toBe(4);\n\n  const mAnchor = new Date('2023-01-31T00:00:00.000Z');\n  const mTo = new Date('2023-03-01T00:00:00.000Z');\n  expect(getIntervalsElapsed(mAnchor, mTo, [1, 'month'])).toBe(0);\n\n  const yAnchor = new Date('2020-01-01T00:00:00.000Z');\n  const yTo = new Date('2022-06-01T00:00:00.000Z');\n  expect(getIntervalsElapsed(yAnchor, yTo, [1, 'year'])).toBe(2);\n});\n"],"mappings":"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"}

package/dist/esm/utils/dev-env-state-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-env-state-path.d.ts","names":[],"sources":["../../../src/utils/dev-env-state-path.ts"],"mappings":";iBAGgB,8BAAA,CAAA;AAAA,iBAQA,uBAAA,CAAA"}
+{"version":3,"file":"dev-env-state-path.d.ts","names":[],"sources":["../../../src/utils/dev-env-state-path.ts"],"mappings":";iBAGgB,8BAAA;AAAA,iBAQA,uBAAA"}