{"version":3,"sources":["../src/index.ts","../src/normalize.ts","../src/hash.ts","../src/encode.ts","../src/api.ts","../src/legacy.ts","../src/validation.ts","../src/compat.ts","../src/zpk.ts"],"sourcesContent":["export type { ZeusAlgorithm, ZeusFormat, ZeusOptions } from \"./types\";\n\nexport { normalizeTime } from \"./normalize\";\n\nexport {\n  zeusHash,\n  generateZeusHash,\n  verifyZeusHash,\n  unixToZeusSync,\n  unixToZeus,\n  zeusToUnix\n} from \"./api\";\n\nexport { legacyUnixToZeus, legacyZeusHash } from \"./legacy\";\n\n// v0.1 compatibility helpers\nexport { validateZeusTimestamp, executeAtZeusEpoch, legacyZeusToUnix } from \"./compat\";\n\nexport {\n  isValidUnixTimestampSeconds,\n  isValidZeusHex,\n  isValidZeusBase64Url\n} from \"./validation\";\n\n// ZPK1 packed payload helpers\nexport type { CanonMode, HashAlgo, PackOptions, ZPKParsed } from \"./zpk\";\nexport { packZPK1, unpackZPK1, isValidZPK1 } from \"./zpk\";\n","// Normalization rules for hashing.\n// Output is always an ISO 8601 string in UTC with milliseconds.\n\nexport function normalizeTime(input: string | number | Date): string {\n  if (input instanceof Date) return input.toISOString();\n\n  if (typeof input === \"number\") {\n    // Heuristic: treat small numbers as seconds, large numbers as ms.\n    const ms = input < 1e12 ? input * 1000 : input;\n    const d = new Date(ms);\n    if (isNaN(d.getTime())) throw new Error(\"Invalid UNIX timestamp number.\");\n    return d.toISOString();\n  }\n\n  if (typeof input === \"string\") {\n    // Determinism rule: only accept ISO 8601 strings that include an explicit timezone (Z or +/-HH:MM).\n    // Avoid locale-dependent parsing like \"01/02/2025 10:00\" which can differ across runtimes.\n    const ISO_WITH_TZ =\n      /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?(?:Z|[+-]\\d{2}:\\d{2})$/;\n\n    if (!ISO_WITH_TZ.test(input)) {\n      throw new Error(\n        \"Invalid timestamp string. Expected ISO 8601 with timezone, for example 2025-01-01T00:00:00Z.\"\n      );\n    }\n\n    const d = new Date(input);\n    if (isNaN(d.getTime())) {\n      throw new Error(\"Invalid timestamp string. Could not parse ISO 8601 value.\");\n    }\n    return d.toISOString();\n  }\n\n  throw new Error(\"Invalid timestamp input.\");\n}\n","import { blake3 } from \"@noble/hashes/blake3\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { utf8ToBytes } from \"@noble/hashes/utils\";\nimport { bytesToBase64Url, bytesToHex } from \"./encode\";\nimport type { ZeusAlgorithm, ZeusFormat } from \"./types\";\n\nexport function hashTimeNormalized(\n  normalizedIsoUtc: string,\n  algorithm: ZeusAlgorithm,\n  format: ZeusFormat\n): string {\n  const msg = utf8ToBytes(normalizedIsoUtc);\n\n  const digest =\n    algorithm === \"sha256\"\n      ? sha256(msg) // 32 bytes\n      : blake3(msg); // 32 bytes by default\n\n  if (format === \"base64url\") return bytesToBase64Url(digest);\n  return bytesToHex(digest);\n}\n","// Encoding helpers that work in Node, browsers, and React Native (including Expo).\n\nexport function bytesToHex(bytes: Uint8Array): string {\n  let out = \"\";\n  for (let i = 0; i < bytes.length; i++) {\n    out += bytes[i].toString(16).padStart(2, \"0\");\n  }\n  return out;\n}\n\nfunction bytesToBase64(bytes: Uint8Array): string {\n  // Node\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const g: any = globalThis as any;\n  if (typeof g.Buffer !== \"undefined\") {\n    return g.Buffer.from(bytes).toString(\"base64\");\n  }\n\n  // Browser / RN with atob/btoa\n  if (typeof g.btoa === \"function\") {\n    let bin = \"\";\n    for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);\n    return g.btoa(bin);\n  }\n\n  // Fallback: manual base64\n  const chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n  let result = \"\";\n  let i = 0;\n  for (; i + 2 < bytes.length; i += 3) {\n    const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];\n    result += chars[(n >> 18) & 63] + chars[(n >> 12) & 63] + chars[(n >> 6) & 63] + chars[n & 63];\n  }\n  if (i < bytes.length) {\n    const a = bytes[i];\n    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;\n    const n = (a << 16) | (b << 8);\n    result += chars[(n >> 18) & 63] + chars[(n >> 12) & 63];\n    result += i + 1 < bytes.length ? chars[(n >> 6) & 63] : \"=\";\n    result += \"=\";\n  }\n  return result;\n}\n\nexport function bytesToBase64Url(bytes: Uint8Array): string {\n  return bytesToBase64(bytes).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/g, \"\");\n}\n\nexport function constantTimeEqual(a: string, b: string): boolean {\n  // Constant time compare for strings without Node crypto dependency.\n  if (a.length !== b.length) return false;\n  let diff = 0;\n  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);\n  return diff === 0;\n}\n","import type { ZeusOptions } from \"./types\";\nimport { normalizeTime } from \"./normalize\";\nimport { hashTimeNormalized } from \"./hash\";\nimport { constantTimeEqual } from \"./encode\";\n\nexport function zeusHash(input: string | number | Date, options: ZeusOptions = {}): string {\n  const algorithm = options.algorithm ?? \"blake3\";\n  const format = options.format ?? \"hex\";\n  const iso = normalizeTime(input);\n  return hashTimeNormalized(iso, algorithm, format);\n}\n\n// Backward compatible name (v0.1 used async hashing)\nexport async function generateZeusHash(input: string | number | Date, options: ZeusOptions = {}): Promise<string> {\n  return zeusHash(input, options);\n}\n\nexport function verifyZeusHash(\n  input: string | number | Date,\n  expectedHash: string,\n  options: ZeusOptions = {}\n): boolean {\n  const actual = zeusHash(input, options);\n  return constantTimeEqual(actual, expectedHash);\n}\n\n// Convenience wrappers for unix seconds and unix ms.\nexport function unixToZeusSync(unix: number, options: ZeusOptions = {}): string {\n  return zeusHash(unix, options);\n}\n\n// Backward compatible signature for v0.1 consumers.\n// Awaiting a string is fine at runtime, but this preserves the Promise return type\n// for TypeScript projects that were written against v0.1.\nexport async function unixToZeus(unix: number, options: ZeusOptions = {}): Promise<string> {\n  return unixToZeusSync(unix, options);\n}\n\n// There is no cryptographic reverse. This function name remains for clarity.\n// If you need reverse mapping, that is a lookup problem and requires storing mappings.\nexport function zeusToUnix(_zeusHash?: string): never {\n  throw new Error(\"ZEUS hashes are one-way. Use the original timestamp or implement a lookup store if you need reverse mapping.\");\n}\n","import type { ZeusOptions } from \"./types\";\nimport { zeusHash } from \"./api\";\n\n// Legacy helpers for environments that do not want BLAKE3.\n// These use SHA-256 and remain one-way.\n\nexport function legacyUnixToZeus(unix: number, format: ZeusOptions[\"format\"] = \"hex\"): string {\n  return zeusHash(unix, { algorithm: \"sha256\", format });\n}\n\nexport function legacyZeusHash(input: string | number | Date, format: ZeusOptions[\"format\"] = \"hex\"): string {\n  return zeusHash(input, { algorithm: \"sha256\", format });\n}\n","export function isValidUnixTimestampSeconds(value: unknown): value is number {\n  return typeof value === \"number\" && Number.isFinite(value) && value >= 0 && value < 1e11;\n}\n\nexport function isValidZeusHex(hash: unknown): hash is string {\n  return typeof hash === \"string\" && /^[a-f0-9]{64}$/.test(hash);\n}\n\nexport function isValidZeusBase64Url(hash: unknown): hash is string {\n  return typeof hash === \"string\" && /^[A-Za-z0-9_-]{43}$/.test(hash);\n}\n","import { verifyZeusHash, unixToZeusSync } from \"./api\";\nimport { isValidZeusBase64Url, isValidZeusHex } from \"./validation\";\n\n// Compatibility surface for v0.1.x consumers.\n\n/**\n * v0.1 export: validateZeusTimestamp(timestamp, expectedHash)\n * Returns true if the computed hash for the timestamp matches expectedHash.\n */\nexport async function validateZeusTimestamp(timestamp: string, expectedHash: string): Promise<boolean> {\n  const okFormat = isValidZeusHex(expectedHash) || isValidZeusBase64Url(expectedHash);\n  if (!okFormat) return false;\n\n  try {\n    return verifyZeusHash(timestamp, expectedHash);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * v0.1 export: executeAtZeusEpoch(epochTime, callback)\n * Polls once per second and triggers callback when current unix seconds hash equals epoch hash.\n */\nexport async function executeAtZeusEpoch(epochTime: number, callback: () => void): Promise<void> {\n  const targetHash = unixToZeusSync(epochTime);\n\n  const interval = setInterval(() => {\n    const now = Math.floor(Date.now() / 1000);\n    const currentHash = unixToZeusSync(now);\n\n    if (currentHash === targetHash) {\n      clearInterval(interval);\n      callback();\n    }\n  }, 1000);\n}\n\n\n/**\n * v0.1 export: legacyZeusToUnix(zeusTime)\n * ZEUS hashes are one-way. This function throws and exists for API continuity.\n */\nfunction looksLikeIso(input: string): boolean {\n  // Loose but practical ISO check\n  return /^\\d{4}-\\d{2}-\\d{2}T/.test(input);\n}\n\nexport function legacyZeusToUnix(zeusTime: string): number {\n  if (looksLikeIso(zeusTime)) {\n    const ms = Date.parse(zeusTime);\n    if (!Number.isFinite(ms)) {\n      throw new Error(\"Invalid ISO timestamp. Cannot convert to unix seconds.\");\n    }\n    return Math.floor(ms / 1000);\n  }\n\n  // Hashes remain one way, do not pretend otherwise\n  throw new Error(\n    \"Input appears to be a ZEUS hash. ZEUS hashes are one-way. Use the original timestamp or a lookup store for reverse mapping.\"\n  );\n}\n","import { blake3 } from \"@noble/hashes/blake3\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { utf8ToBytes } from \"@noble/hashes/utils\";\nimport { bytesToHex } from \"./encode\";\n\nexport type CanonMode = \"utf8_exact\" | \"json_sorted_compact\" | \"bytes_b64\";\nexport type HashAlgo = \"blake3\" | \"sha256\";\n\nexport interface PackOptions {\n  canon: CanonMode;\n  algo?: HashAlgo; // default: blake3\n  tag?: string;\n}\n\nexport interface ZPKParsed {\n  canon: CanonMode;\n  algo: HashAlgo;\n  tag?: string;\n  digest: string; // lowercase hex\n}\n\n// -------------------------\n// Internal helpers\n// -------------------------\n\nfunction assertNoWhitespace(s: string): void {\n  if (/\\s/.test(s)) throw new Error(\"ZPK1 contains whitespace, which is not permitted.\");\n}\n\nfunction assertTag(tag: string): void {\n  if (tag.length === 0) throw new Error(\"ZPK1 tag must not be empty.\");\n  if (tag.includes(\"|\") || tag.includes(\"=\")) throw new Error(\"ZPK1 tag must not include '|' or '=' characters.\");\n}\n\nfunction isLowerHex64(s: string): boolean {\n  return /^[0-9a-f]{64}$/.test(s);\n}\n\nfunction sortJson(value: unknown): unknown {\n  if (value === null) return null;\n  if (typeof value !== \"object\") return value;\n  if (Array.isArray(value)) return value.map(sortJson);\n\n  const obj = value as Record<string, unknown>;\n  const keys = Object.keys(obj).sort();\n  const out: Record<string, unknown> = {};\n  for (const k of keys) out[k] = sortJson(obj[k]);\n  return out;\n}\n\n/**\n * Decode base64 or base64url to bytes (strict, no whitespace).\n */\nfunction base64ToBytes(input: string): Uint8Array {\n  assertNoWhitespace(input);\n\n  // Normalize base64url to base64\n  let s = input.replace(/-/g, \"+\").replace(/_/g, \"/\");\n  // Pad to multiple of 4\n  while (s.length % 4 !== 0) s += \"=\";\n\n  // Node\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const g: any = globalThis as any;\n  if (typeof g.Buffer !== \"undefined\") {\n    return new Uint8Array(g.Buffer.from(s, \"base64\"));\n  }\n\n  // Browser / RN with atob\n  if (typeof g.atob === \"function\") {\n    const bin = g.atob(s);\n    const out = new Uint8Array(bin.length);\n    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);\n    return out;\n  }\n\n  // Manual decode (fallback)\n  const chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n  const rev: Record<string, number> = {};\n  for (let i = 0; i < chars.length; i++) rev[chars[i]] = i;\n\n  const cleaned = s.replace(/=+$/g, \"\");\n  const bytes: number[] = [];\n  let buffer = 0;\n  let bits = 0;\n\n  for (let i = 0; i < cleaned.length; i++) {\n    const c = cleaned[i];\n    const v = rev[c];\n    if (v === undefined) throw new Error(\"Invalid base64 character in bytes_b64 payload.\");\n    buffer = (buffer << 6) | v;\n    bits += 6;\n    if (bits >= 8) {\n      bits -= 8;\n      bytes.push((buffer >> bits) & 0xff);\n    }\n  }\n\n  return new Uint8Array(bytes);\n}\n\nfunction canonicalizeToBytes(payload: unknown, canon: CanonMode): Uint8Array {\n  if (canon === \"utf8_exact\") {\n    if (typeof payload !== \"string\") throw new Error(\"utf8_exact canon requires a string payload.\");\n    return utf8ToBytes(payload);\n  }\n\n  if (canon === \"json_sorted_compact\") {\n    // Accept any JSON-serializable input; enforce by JSON.stringify\n    const sorted = sortJson(payload);\n    const compact = JSON.stringify(sorted);\n    if (typeof compact !== \"string\") throw new Error(\"Failed to stringify JSON payload.\");\n    return utf8ToBytes(compact);\n  }\n\n  // bytes_b64\n  if (payload instanceof Uint8Array) return payload;\n  if (typeof payload !== \"string\") throw new Error(\"bytes_b64 canon requires a base64/base64url string or Uint8Array payload.\");\n  return base64ToBytes(payload);\n}\n\nfunction hashBytes(bytes: Uint8Array, algo: HashAlgo): Uint8Array {\n  return algo === \"sha256\" ? sha256(bytes) : blake3(bytes);\n}\n\n// -------------------------\n// Public API\n// -------------------------\n\n/**\n * Pack a payload into a ZPK1 string.\n *\n * ZPK1 contains no raw data, only metadata and a digest.\n * Output is strict and deterministic.\n */\nexport function packZPK1(payload: unknown, opts: PackOptions): string {\n  const canon = opts.canon;\n  const algo: HashAlgo = opts.algo ?? \"blake3\";\n\n  if (algo !== \"blake3\" && algo !== \"sha256\") {\n    throw new Error(\"Invalid algo. Expected 'blake3' or 'sha256'.\");\n  }\n\n  const bytes = canonicalizeToBytes(payload, canon);\n  const digestHex = bytesToHex(hashBytes(bytes, algo));\n\n  if (!isLowerHex64(digestHex)) {\n    throw new Error(\"Invalid digest produced. Expected 64 lowercase hex characters.\");\n  }\n\n  if (opts.tag !== undefined) assertTag(opts.tag);\n\n  const base = `ZPK1|canon=${canon}|algo=${algo}`;\n  if (opts.tag) return `${base}|tag=${opts.tag}|digest=${digestHex}`;\n  return `${base}|digest=${digestHex}`;\n}\n\n/**\n * Parse and validate a ZPK1 string.\n * Throws on any violation.\n */\nexport function unpackZPK1(packed: string): ZPKParsed {\n  if (typeof packed !== \"string\") throw new Error(\"ZPK1 must be a string.\");\n  assertNoWhitespace(packed);\n\n  const parts = packed.split(\"|\");\n  if (parts[0] !== \"ZPK1\") throw new Error(\"Invalid packed payload: expected prefix ZPK1.\");\n\n  // Either 4 parts (no tag) or 5 parts (with tag)\n  if (parts.length !== 4 && parts.length !== 5) {\n    throw new Error(\"Invalid packed payload: expected 4 or 5 pipe-delimited parts.\");\n  }\n\n  const canonPart = parts[1];\n  const algoPart = parts[2];\n\n  const canon = canonPart.startsWith(\"canon=\") ? canonPart.slice(6) : null;\n  if (!canon) throw new Error(\"Invalid packed payload: missing canon field.\");\n  if (canon !== \"utf8_exact\" && canon !== \"json_sorted_compact\" && canon !== \"bytes_b64\") {\n    throw new Error(\"Invalid packed payload: unsupported canon value.\");\n  }\n\n  const algo = algoPart.startsWith(\"algo=\") ? algoPart.slice(5) : null;\n  if (!algo) throw new Error(\"Invalid packed payload: missing algo field.\");\n  if (algo !== \"blake3\" && algo !== \"sha256\") {\n    throw new Error(\"Invalid packed payload: unsupported algo value.\");\n  }\n\n  let tag: string | undefined;\n  let digestPart: string;\n\n  if (parts.length === 5) {\n    const tagPart = parts[3];\n    if (!tagPart.startsWith(\"tag=\")) throw new Error(\"Invalid packed payload: expected tag field.\");\n    tag = tagPart.slice(4);\n    assertTag(tag);\n\n    digestPart = parts[4];\n  } else {\n    digestPart = parts[3];\n  }\n\n  if (!digestPart.startsWith(\"digest=\")) throw new Error(\"Invalid packed payload: missing digest field.\");\n  const digest = digestPart.slice(7);\n\n  if (!isLowerHex64(digest)) {\n    throw new Error(\"Invalid packed payload: digest must be 64 lowercase hex characters.\");\n  }\n\n  return { canon, algo, tag, digest } as ZPKParsed;\n}\n\n/**\n * Returns true if packed is valid ZPK1, otherwise false.\n */\nexport function isValidZPK1(packed: string): boolean {\n  try {\n    unpackZPK1(packed);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":"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","names":["i","import_blake3","import_sha256","import_utils"]}