@magmacomputing/tempo-plugin-geo 0.1.0 → 1.1.0

package/dist/index.js

@@ -257,31 +257,55 @@ var init_type_library = __esm({
 });
 
 // ../../library/dist/common/primitives/assertion.library.js
-var isType, isPrimitive, isReference, isString, isNumber, isInteger, isArray, isObject, isDate, isSymbol, isSymbolFor, isSafeKey, isNullish, isUndefined, isDefined, isFunction, isMap, isSet, isError, isEmpty;
+function isNumeric(str) {
+  const type = typeof str;
+  switch (type) {
+    case "number":
+      return Number.isFinite(str);
+    case "bigint":
+      return true;
+    case "string": {
+      const val = str.trim();
+      if (val.length === 0)
+        return false;
+      return RE_BIGINT_LITERAL.test(val) || isNumber(Number(val));
+    }
+    default:
+      return false;
+  }
+}
+var isType, isPrimitive, isReference, isIterable, isString, isText, isNumber, RE_BIGINT_LITERAL, isInteger, isArray, isArrayLike, isObject, isDate, isRegExp, isSymbol, isSymbolFor, isSafeKey, isNullish, isUndefined, isDefined, isFunction, isCallable, isMap, isSet, isError, isLocale, isEmpty;
 var init_assertion_library = __esm({
   "../../library/dist/common/primitives/assertion.library.js"() {
     "use strict";
     init_symbol_library();
     init_type_library();
     isType = (obj, ...types) => types.includes(getType(obj));
-    isPrimitive = (obj) => isType(obj, "String", "Number", "BigInt", "Boolean", "Symbol", "Undefined", "Void", "Null", "Empty");
+    isPrimitive = (obj) => obj === null || typeof obj !== "object" && typeof obj !== "function";
     isReference = (obj) => !isPrimitive(obj);
-    isString = (obj) => isType(obj, "String");
+    isIterable = (obj) => Symbol.iterator in Object(obj) && !isString(obj);
+    isString = (obj) => typeof obj === "string";
+    isText = (obj) => typeof obj === "string" && obj.trim().length > 0;
     isNumber = (obj) => Number.isFinite(obj);
-    isInteger = (obj) => isType(obj, "BigInt");
-    isArray = (obj) => isType(obj, "Array");
+    RE_BIGINT_LITERAL = /^[+-]?[0-9]+n$/;
+    isInteger = (obj) => typeof obj === "bigint";
+    isArray = (obj) => Array.isArray(obj);
+    isArrayLike = (obj) => protoType(obj) === "Object" && "length" in obj && Object.keys(obj).every((key) => key === "length" || isNumber(Number(key)));
     isObject = (obj) => isType(obj, "Object");
     isDate = (obj) => isType(obj, "Date");
-    isSymbol = (obj) => isType(obj, "Symbol");
-    isSymbolFor = (obj) => isType(obj, "Symbol") && Symbol.keyFor(obj) !== void 0;
+    isRegExp = (obj) => isType(obj, "RegExp");
+    isSymbol = (obj) => typeof obj === "symbol";
+    isSymbolFor = (obj) => typeof obj === "symbol" && Symbol.keyFor(obj) !== void 0;
     isSafeKey = (key) => key !== "__proto__" && key !== "constructor" && key !== "prototype";
-    isNullish = (obj) => isType(obj, "Null", "Undefined", "Void", "Empty");
-    isUndefined = (obj) => isType(obj, "Undefined", "Void", "Empty");
-    isDefined = (obj) => !isNullish(obj);
+    isNullish = (obj) => obj === null || obj === void 0 || isType(obj, "Void", "Empty");
+    isUndefined = (obj) => obj === void 0 || isType(obj, "Void", "Empty");
+    isDefined = (obj) => obj !== null && obj !== void 0 && !isNullish(obj);
     isFunction = (obj) => isType(obj, "Function", "AsyncFunction", "GeneratorFunction", "AsyncGeneratorFunction");
+    isCallable = (obj) => typeof obj === "function";
     isMap = (obj) => isType(obj, "Map");
     isSet = (obj) => isType(obj, "Set");
     isError = (err, constructor) => isType(err, "Error") && (constructor ? err instanceof constructor : true);
+    isLocale = (obj) => typeof Intl !== "undefined" && typeof Intl.Locale === "function" && obj instanceof Intl.Locale;
     isEmpty = (obj) => isNullish(obj) || isObject(obj) && Reflect.ownKeys(obj).length === 0 || isString(obj) && obj.trim().length === 0 || typeof obj === "number" && Number.isNaN(obj) || isArray(obj) && obj.length === 0 || isSet(obj) && obj.size === 0 || isMap(obj) && obj.size === 0 || ArrayBuffer.isView(obj) && obj.byteLength === 0 || isDate(obj) && Number.isNaN(obj.getTime());
   }
 });
@@ -340,37 +364,6 @@ var init_utility_library = __esm({
   }
 });
 
-// ../../library/dist/common/primitives/object.library.js
-function looseIndex(arg) {
-  if (isDefined(arg))
-    return isFunction(arg) ? arg() : arg;
-  return (obj) => isFunction(obj) ? obj() : obj;
-}
-var asObject;
-var init_object_library = __esm({
-  "../../library/dist/common/primitives/object.library.js"() {
-    "use strict";
-    init_primitive_library();
-    init_assertion_library();
-    init_type_library();
-    asObject = (obj) => {
-      if (isNullish(obj) || !isObject(obj))
-        return obj;
-      const temp = isArray(obj) ? [] : {};
-      ownKeys(obj).forEach((key) => {
-        if (!isSafeKey(key))
-          return;
-        temp[key] = asObject(obj[key]);
-      });
-      return temp;
-    };
-    looseIndex.stringSymbol = looseIndex();
-    looseIndex.symbolRegExp = looseIndex();
-    looseIndex.symbolString = looseIndex();
-    looseIndex.stringString = looseIndex();
-  }
-});
-
 // ../../library/dist/common/runtime/reflection.library.js
 function allObject(json) {
   return Object.fromEntries(ownEntries(json, true));
@@ -544,6 +537,8 @@ function serialize(val, seen = /* @__PURE__ */ new WeakSet()) {
       if (seen.has(value2))
         return "<Circular>";
       seen.add(value2);
+      if (isLocale(value2))
+        return value2.toString();
       if (isMap(value2))
         return `map:[${Array.from(value2.entries()).map((e) => serialize(e, seen)).sort().join(",")}]`;
       if (isSet(value2))
@@ -600,15 +595,86 @@ var init_function_library = __esm({
 });
 
 // ../../library/dist/common/runtime/json.library.js
+function cleanify(obj) {
+  try {
+    return JSON.parse(JSON.stringify(obj));
+  } catch (error) {
+    console.warn("Could not clean object:", error?.message ?? error);
+    throw error;
+  }
+}
 var init_json_library = __esm({
   "../../library/dist/common/runtime/json.library.js"() {
     "use strict";
+    init_assertion_library();
+  }
+});
+
+// ../../library/dist/common/primitives/object.library.js
+function looseIndex(arg) {
+  if (isDefined(arg))
+    return isFunction(arg) ? arg() : arg;
+  return (obj) => isFunction(obj) ? obj() : obj;
+}
+var getObjectKeys, asObject;
+var init_object_library = __esm({
+  "../../library/dist/common/primitives/object.library.js"() {
+    "use strict";
+    init_primitive_library();
+    init_assertion_library();
+    init_type_library();
+    getObjectKeys = (obj) => {
+      const keys = /* @__PURE__ */ new Set();
+      let curr = obj;
+      let depth = 0;
+      while (curr && curr !== Object.prototype && depth++ < 10) {
+        const descs = Object.getOwnPropertyDescriptors(curr);
+        for (const [key, desc] of Object.entries(descs)) {
+          if (!isSafeKey(key))
+            continue;
+          if (desc.enumerable || isFunction(desc.get)) {
+            keys.add(key);
+          }
+        }
+        curr = Object.getPrototypeOf(curr);
+      }
+      return Array.from(keys);
+    };
+    asObject = (obj) => {
+      if (isPrimitive(obj) || isFunction(obj))
+        return obj;
+      if (isArray(obj))
+        return obj.map((item) => asObject(item));
+      if (isDate(obj) || isRegExp(obj) || isMap(obj) || isSet(obj))
+        return obj;
+      try {
+        if (isFunction(obj.toJSON))
+          return asObject(obj.toJSON());
+      } catch {
+      }
+      const temp = {};
+      for (const key of getObjectKeys(obj)) {
+        try {
+          temp[key] = asObject(obj[key]);
+        } catch {
+        }
+      }
+      return temp;
+    };
+    looseIndex.stringSymbol = looseIndex();
+    looseIndex.symbolRegExp = looseIndex();
+    looseIndex.symbolString = looseIndex();
+    looseIndex.stringString = looseIndex();
   }
 });
 
 // ../../library/dist/common/runtime/serialize.library.js
-function replacer(key, obj) {
-  return isEmpty(key) ? obj : stringize(obj);
+function clone(obj, opts) {
+  try {
+    return globalThis.structuredClone(obj, opts);
+  } catch {
+    return cleanify(obj);
+  }
 }
 function reviver(_key, val) {
   return decode(val);
@@ -654,19 +720,34 @@ function toSymbol(value2) {
       return Symbol(desc);
   }
 }
-function stringify(obj) {
-  return stringize(obj, false);
+function stringify(obj, options) {
+  const prevCompact = activeCompact;
+  activeCompact = options?.compact !== false;
+  try {
+    const str = stringize(obj, false);
+    if (options?.signed) {
+      if (!isString(options.secret) || !options.secret)
+        throw new TypeError("stringify: signed serialization requires an explicit secret string");
+      return `$sig:${fastDigest(str, options.secret)}:${str}`;
+    }
+    return str;
+  } finally {
+    activeCompact = prevCompact;
+  }
 }
 function stringize(obj, recurse = true) {
   const arg = asType(obj);
   const one = curry(oneKey)(arg.type);
   switch (arg.type) {
-    case "String":
+    case "String": {
+      let strVal = arg.value;
+      if (strVal.startsWith("~"))
+        strVal = `~${strVal}`;
       if (!recurse) {
-        recurse = arg.value === "true" || arg.value === "false" || arg.value === "null" || parseFloat(arg.value).toString() === arg.value;
+        recurse = strVal === "true" || strVal === "false" || strVal === "null" || parseFloat(strVal).toString() === strVal || strVal.startsWith("~");
       }
-      return recurse ? JSON.stringify(encode(arg.value)) : encode(arg.value);
-    // dont JSON.stringify a top-level string
+      return recurse ? JSON.stringify(encode(strVal)) : encode(strVal);
+    }
     case "Boolean":
     case "Null":
     case "Number":
@@ -674,11 +755,13 @@ function stringize(obj, recurse = true) {
     // JSON.stringify will correctly handle these
     case "Void":
     case "Undefined":
-      return one(JSON.stringify("void"));
+      return activeCompact ? JSON.stringify("~u") : one(JSON.stringify("void"));
     // preserve 'undefined' values		
     case "BigInt":
-      return one(arg.value.toString());
+      return activeCompact ? JSON.stringify(`~n${arg.value.toString()}`) : one(arg.value.toString());
     // even though BigInt has a toString method, it is not supported in JSON.stringify
+    case "Date":
+      return activeCompact ? JSON.stringify(`~t${arg.value.getTime()}`) : one(stringize(arg.value.toJSON()));
     case "Object": {
       const obj2 = ownEntries(arg.value).filter(([, val]) => isStringable(val)).map(([key, val]) => `${fromSymbol(key)}: ${stringize(val)}`).join(",");
       return `{${obj2}}`;
@@ -695,8 +778,10 @@ function stringize(obj, recurse = true) {
       const set = Array.from(arg.value.values()).filter((val) => isStringable(val)).map((val) => stringize(val)).join(",");
       return one(`[${set}]`);
     }
-    case "Symbol":
-      return one(fromSymbol(arg.value));
+    case "Symbol": {
+      const symStr = `${isSymbolFor(arg.value) ? "@" : ""}@(${arg.value.description ?? ""})`;
+      return activeCompact ? JSON.stringify(`~y${symStr}`) : one(JSON.stringify(symStr));
+    }
     case "RegExp":
       return one(stringize({ source: arg.value.source, flags: arg.value.flags }));
     case "Class":
@@ -707,21 +792,55 @@ function stringize(obj, recurse = true) {
           return void 0;
         case isFunction(value2.toJSON):
           return one(stringize(value2.toJSON()));
-        case isFunction(value2.toString): {
+        case (isFunction(value2.toString) && value2.toString !== Object.prototype.toString): {
           const str = value2.toString();
           return one(str.includes('"') ? str : JSON.stringify(str));
         }
-        case isFunction(value2.valueOf):
+        case (isFunction(value2.valueOf) && value2.valueOf !== Object.prototype.valueOf):
           return one(JSON.stringify(value2.valueOf()));
-        default:
-          return one(JSON.stringify(value2, replacer));
+        default: {
+          const plain = asObject(value2);
+          return isReference(plain) && Object.keys(plain).length > 0 ? stringize(plain) : one(JSON.stringify(value2, (key, o) => isEmpty(key) ? o : stringize(o)));
+        }
       }
     }
   }
 }
-function objectify(str, sentinel) {
+function objectify(str, optionsOrSentinel) {
   if (!isString(str))
     return str;
+  const options = isFunction(optionsOrSentinel) ? { sentinel: optionsOrSentinel } : optionsOrSentinel ?? {};
+  if (str.startsWith("$sig:")) {
+    const secondColon = str.indexOf(":", 5);
+    if (secondColon !== -1) {
+      const sig = str.substring(5, secondColon);
+      const payload = str.substring(secondColon + 1);
+      if (!isString(options.secret) || !options.secret) {
+        console.warn("objectify: signature verification requires an explicit secret string");
+        if (options.throwOnError)
+          throw new TypeError("objectify: signature verification requires an explicit secret string");
+        return str;
+      }
+      const expectedSig = fastDigest(payload, options.secret);
+      if (!constantTimeEqual(sig, expectedSig)) {
+        console.warn("objectify: signature verification failed");
+        if (options.throwOnError)
+          throw new Error("objectify: signature verification failed");
+        return str;
+      }
+      str = payload;
+    } else if (options.requireSigned) {
+      console.warn("objectify: malformed signed payload");
+      if (options.throwOnError)
+        throw new Error("objectify: malformed signed payload");
+      return str;
+    }
+  } else if (options.requireSigned) {
+    console.warn("objectify: unsigned string rejected by requireSigned policy");
+    if (options.throwOnError)
+      throw new Error("objectify: unsigned string rejected by requireSigned policy");
+    return str;
+  }
   let parse;
   try {
     parse = JSON.parse(str, reviver);
@@ -730,28 +849,50 @@ function objectify(str, sentinel) {
       console.warn(`objectify.parse: -> ${str}, ${error.message}`);
       return str;
     } else
-      return objectify(`"${str}"`, sentinel);
+      return objectify(`"${str}"`, options.requireSigned ? { ...options, requireSigned: false } : options);
   }
   switch (true) {
     case (str.startsWith("{") && str.endsWith("}")):
     // looks like Object
     case (str.startsWith("[") && str.endsWith("]")):
-      return traverse(parse, sentinel);
+      return traverse(parse, options, 0);
     // recurse into object
     default:
-      return parse;
+      return typeify(parse, options);
   }
 }
-function traverse(obj, sentinel) {
+function traverse(obj, options, depth = 0) {
+  const maxDepth = options.maxDepth ?? MAX_TRAVERSE_DEPTH;
+  if (depth >= maxDepth)
+    return obj;
   if (isObject(obj)) {
-    return typeify(ownEntries(obj).reduce((acc, [key, val]) => Object.assign(acc, { [toSymbol(key)]: typeify(traverse(val, sentinel)) }), {}), sentinel);
+    return typeify(ownEntries(obj).filter(([key]) => isSafeKey(key)).reduce((acc, [key, val]) => Object.assign(acc, { [toSymbol(key)]: typeify(traverse(val, options, depth + 1), options) }), {}), options);
   }
   if (isArray(obj)) {
-    return ownValues(obj).map((val) => typeify(traverse(val, sentinel)));
+    return ownValues(obj).map((val) => typeify(traverse(val, options, depth + 1), options));
   }
-  return obj;
+  return typeify(obj, options);
 }
-function typeify(json, sentinel) {
+function typeify(json, options) {
+  if (isString(json) && json.startsWith("~")) {
+    try {
+      if (json.startsWith("~~"))
+        return json.substring(1);
+      if (json.startsWith("~n"))
+        return BigInt(json.substring(2));
+      if (json.startsWith("~t")) {
+        const timeVal = json.substring(2);
+        const d = new Date(isNumeric(timeVal) ? Number(timeVal) : timeVal);
+        return isNaN(d.getTime()) ? json : d;
+      }
+      if (json === "~u")
+        return options.sentinel?.();
+      if (json.startsWith("~y"))
+        return toSymbol(json.substring(2));
+    } catch {
+      return json;
+    }
+  }
   if (!isObject(json) || ownKeys(json).length !== 1)
     return json;
   const [$type, value2] = ownEntries(json)[0];
@@ -775,12 +916,14 @@ function typeify(json, sentinel) {
       case "Undefined":
       case "Empty":
       case "Void":
-        return sentinel?.();
+        return options.sentinel?.();
       // run Sentinel function to handle undefined values
       case "Date":
         return new Date(value2);
       case "RegExp":
-        if (!isObject(value2) || !isString(value2.source))
+        if (options.allowRegExp === false)
+          return json;
+        if (!isObject(value2) || !isString(value2.source) || value2.source.length > MAX_REGEXP_SOURCE_LENGTH)
           return json;
         return new RegExp(value2.source, value2.flags);
       case "Symbol":
@@ -793,25 +936,34 @@ function typeify(json, sentinel) {
         if (!isArray(value2))
           return json;
         return new Set(value2);
-      default:
+      default: {
+        if (options.allowClasses === false)
+          return json;
+        if (options.allowedClasses) {
+          const allowed = options.allowedClasses instanceof Set ? options.allowedClasses.has($type) || options.allowedClasses.has(type) : options.allowedClasses.includes($type) || options.allowedClasses.includes(type);
+          if (!allowed)
+            return json;
+        }
         const cls = Registry.get($type);
         if (!cls) {
           console.warn(`objectify: dont know how to deserialize '${type}'`);
           return json;
         }
         return Reflect.construct(cls, [value2]);
+      }
     }
   } catch {
     return json;
   }
 }
-var Registry, getSafeTag2, registerSerializable, SAFE_URI_MAP, RE_SAFE_URI_CODES, symKey;
+var Registry, getSafeTag2, registerSerializable, SAFE_URI_MAP, RE_SAFE_URI_CODES, symKey, RUNTIME_SALT, fastDigest, constantTimeEqual, activeCompact, MAX_TRAVERSE_DEPTH, MAX_REGEXP_SOURCE_LENGTH;
 var init_serialize_library = __esm({
   "../../library/dist/common/runtime/serialize.library.js"() {
     "use strict";
     init_function_library();
     init_primitive_library();
     init_json_library();
+    init_object_library();
     init_type_library();
     init_assertion_library();
     init_symbol_library();
@@ -854,6 +1006,582 @@ var init_serialize_library = __esm({
     };
     RE_SAFE_URI_CODES = new RegExp(Object.keys(SAFE_URI_MAP).join("|"), "gi");
     symKey = /^@(@)?\(([^\)]*)\)$/;
+    RUNTIME_SALT = globalThis.crypto?.randomUUID ? globalThis.crypto.randomUUID().split("-")[0] : Math.random().toString(36).slice(2, 10);
+    fastDigest = (str, secret = RUNTIME_SALT) => {
+      let h1 = 2166136261;
+      let h2 = 2654435769;
+      const input = `${secret}:${str}`;
+      for (let i = 0; i < input.length; i++) {
+        const c = input.charCodeAt(i);
+        h1 = Math.imul(h1 ^ c, 16777619);
+        h2 = Math.imul(h2 ^ c, 2246822507);
+      }
+      return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+    };
+    constantTimeEqual = (a, b) => {
+      if (!isString(a) || !isString(b))
+        return false;
+      if (a.length !== b.length)
+        return false;
+      let result = 0;
+      for (let i = 0; i < a.length; i++)
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+      return result === 0;
+    };
+    activeCompact = true;
+    MAX_TRAVERSE_DEPTH = 64;
+    MAX_REGEXP_SOURCE_LENGTH = 512;
+  }
+});
+
+// ../../../node_modules/tslib/tslib.es6.mjs
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context3 = {};
+    for (var p in contextIn) context3[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context3.access[p] = contextIn.access[p];
+    context3.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context3);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+}
+function __runInitializers(thisArg, initializers, value2) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value2 = useValue ? initializers[i].call(thisArg, value2) : initializers[i].call(thisArg);
+  }
+  return useValue ? value2 : void 0;
+}
+var init_tslib_es6 = __esm({
+  "../../../node_modules/tslib/tslib.es6.mjs"() {
+    "use strict";
+  }
+});
+
+// ../../library/dist/common/runtime/decorator.library.js
+function getClassName(value2, contextName) {
+  return getSafeTag(value2) ?? (isUndefined(contextName) ? value2.name || void 0 : String(contextName));
+}
+function Serializable(value2, { kind, name, addInitializer }) {
+  const finalName = getClassName(value2, name);
+  if (finalName)
+    registerType(value2, finalName);
+  switch (kind) {
+    case "class":
+      if (finalName)
+        addInitializer(() => registerSerializable(finalName, value2));
+      return value2;
+    default:
+      throw new Error(`@Serializable decorating unknown 'kind': ${kind} (${name})`);
+  }
+}
+function StringTag(tagOrValue, context3) {
+  const applyTag = (value2, customTag, contextName) => {
+    const proto = value2.prototype;
+    const tagName = customTag ?? getClassName(value2, contextName);
+    if (tagName) {
+      if (proto && !Object.hasOwn(proto, Symbol.toStringTag)) {
+        Object.defineProperty(proto, Symbol.toStringTag, {
+          value: tagName,
+          configurable: true,
+          writable: false,
+          enumerable: false
+        });
+      }
+      if (!value2.name || value2.name !== tagName) {
+        try {
+          Object.defineProperty(value2, "name", {
+            value: tagName,
+            configurable: true,
+            writable: false,
+            enumerable: false
+          });
+        } catch {
+        }
+      }
+    }
+    return value2;
+  };
+  if (isCallable(tagOrValue) && context3?.kind === "class")
+    return applyTag(tagOrValue, void 0, context3.name);
+  return (value2, ctx) => {
+    return applyTag(value2, isString(tagOrValue) ? tagOrValue : void 0, ctx?.name);
+  };
+}
+var init_decorator_library = __esm({
+  "../../library/dist/common/runtime/decorator.library.js"() {
+    "use strict";
+    init_symbol_library();
+    init_proxy_library();
+    init_assertion_library();
+    init_serialize_library();
+    init_type_library();
+  }
+});
+
+// ../../library/dist/common/runtime/cache.class.js
+var BoundedCache;
+var init_cache_class = __esm({
+  "../../library/dist/common/runtime/cache.class.js"() {
+    "use strict";
+    init_tslib_es6();
+    init_assertion_library();
+    init_decorator_library();
+    BoundedCache = (() => {
+      let _classDecorators = [StringTag("BoundedCache")];
+      let _classDescriptor;
+      let _classExtraInitializers = [];
+      let _classThis;
+      let _classSuper = Map;
+      var BoundedCache2 = class extends _classSuper {
+        static {
+          _classThis = this;
+        }
+        static {
+          const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+          BoundedCache2 = _classThis = _classDescriptor.value;
+          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+          __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #expires = /* @__PURE__ */ new Map();
+        #staticKeys = /* @__PURE__ */ new Set();
+        #ttls = /* @__PURE__ */ new Map();
+        maxSize;
+        ttl;
+        /**
+         * Creates a bounded cache with configurable capacity and entry lifetime.
+         *
+         * @param maxSize - Maximum number of non-static entries retained
+         * @param ttl - Default time-to-live for entries in milliseconds
+         */
+        constructor(maxSize = 1e3, ttl = 24 * 60 * 60 * 1e3) {
+          super();
+          this.maxSize = maxSize;
+          this.ttl = ttl;
+        }
+        /**
+         * Returns true to identify this instance as a BoundedCache.
+         */
+        get isBoundedCache() {
+          return true;
+        }
+        /**
+         * Determines whether a cache entry has passed its expiration deadline.
+         *
+         * @param key - Cache key to inspect
+         * @returns True when the entry has expired, otherwise false
+         */
+        #isExpired(key) {
+          const deadline = this.#expires.get(key);
+          if (deadline === void 0)
+            return false;
+          return Date.now() > deadline;
+        }
+        /**
+         * Purges TTL-expired entries.
+         */
+        evictExpired() {
+          if (this.#expires.size === 0)
+            return;
+          const now = Date.now();
+          for (const [key, deadline] of this.#expires.entries()) {
+            if (now > deadline) {
+              this.delete(key);
+            }
+          }
+        }
+        /**
+         * Register an immortal static key (e.g. business glossary term).
+         * Static keys bypass TTL expiration and LRU capacity eviction.
+         */
+        setStatic(key, value2) {
+          if (super.has(key))
+            super.delete(key);
+          super.set(key, value2);
+          this.#staticKeys.add(key);
+          this.#expires.delete(key);
+          this.#ttls.delete(key);
+          return this;
+        }
+        /**
+         * Check if a key is a static key.
+         */
+        isStatic(key) {
+          return this.#staticKeys.has(key);
+        }
+        /**
+         * Retrieves a value from the cache by key. Evaluates TTL expiration via `#expires`
+         * specifically for the requested key, and updates LRU ordering by deleting and re-inserting
+         * the key in the underlying Map. Leaves the expiration deadline unchanged.
+         *
+         * @param key - The cache key to retrieve
+         * @returns The cached value, or undefined if not found or expired
+         */
+        get(key) {
+          if (this.#isExpired(key)) {
+            this.delete(key);
+            return void 0;
+          }
+          if (!super.has(key))
+            return void 0;
+          const val = super.get(key);
+          super.delete(key);
+          super.set(key, val);
+          return val;
+        }
+        /**
+         * Checks if a key exists in the cache and is not expired.
+         * Automatically evicts expired entries on access.
+         *
+         * @param key - The cache key to check
+         * @returns True if the key exists and is not expired, false otherwise
+         */
+        has(key) {
+          if (this.#isExpired(key)) {
+            this.delete(key);
+            return false;
+          }
+          return super.has(key);
+        }
+        /**
+         * Returns the number of entries in the cache after evicting expired entries.
+         */
+        get size() {
+          this.evictExpired();
+          return super.size;
+        }
+        /**
+         * Executes a callback for each cache entry after evicting expired entries.
+         *
+         * @param callbackfn - Function to execute for each entry
+         * @param thisArg - Optional value to use as `this` when executing the callback
+         */
+        forEach(callbackfn, thisArg) {
+          this.evictExpired();
+          super.forEach(callbackfn, thisArg);
+        }
+        /**
+         * Sets a key-value pair in the cache, enforcing LRU eviction.
+         * If finite-TTL is configured, entries retain their original absolute expiration deadline
+         * unless an explicit `ttl` override is passed.
+         * If the cache exceeds maxSize, the oldest non-static entry is removed.
+         *
+         * @param key - The cache key to set
+         * @param value - The value to store
+         * @param ttl - Optional custom time-to-live in milliseconds for this specific entry
+         * @returns This cache instance for chaining
+         */
+        set(key, value2, ttl) {
+          this.evictExpired();
+          const existingDeadline = this.#expires.get(key);
+          if (super.has(key))
+            super.delete(key);
+          super.set(key, value2);
+          this.#staticKeys.delete(key);
+          if (isDefined(ttl)) {
+            if (ttl !== Infinity) {
+              this.#expires.set(key, Date.now() + ttl);
+              this.#ttls.set(key, ttl);
+            } else {
+              this.#expires.delete(key);
+              this.#ttls.delete(key);
+            }
+          } else if (existingDeadline !== void 0) {
+            this.#expires.set(key, existingDeadline);
+          } else if (this.ttl !== Infinity) {
+            this.#expires.set(key, Date.now() + this.ttl);
+            this.#ttls.delete(key);
+          } else {
+            this.#expires.delete(key);
+            this.#ttls.delete(key);
+          }
+          while (this.size - this.#staticKeys.size > this.maxSize) {
+            let evicted = false;
+            const keysIter = super.keys();
+            let res = keysIter.next();
+            while (!res.done) {
+              const k = res.value;
+              if (!this.#staticKeys.has(k)) {
+                this.delete(k);
+                evicted = true;
+                break;
+              }
+              res = keysIter.next();
+            }
+            if (!evicted)
+              break;
+          }
+          return this;
+        }
+        /**
+         * Deletes a key from the cache, removing its expiration and static key markers.
+         *
+         * @param key - The cache key to delete
+         * @returns True if the key was deleted, false if it did not exist
+         */
+        delete(key) {
+          this.#staticKeys.delete(key);
+          this.#expires.delete(key);
+          this.#ttls.delete(key);
+          return super.delete(key);
+        }
+        /**
+         * Deletes all cache entries whose keys start with the specified prefix.
+         * The prefix comparison is case-insensitive.
+         *
+         * @param prefix - The prefix string to match against cache keys
+         * @returns The number of entries deleted
+         */
+        deletePrefix(prefix) {
+          const normalizedPrefix = String(prefix).trim().toLowerCase();
+          if (isEmpty(normalizedPrefix))
+            return 0;
+          const toDelete = [];
+          for (const key of super.keys()) {
+            if (isString(key) && key.toLowerCase().startsWith(normalizedPrefix))
+              toDelete.push(key);
+          }
+          for (const k of toDelete)
+            this.delete(k);
+          return toDelete.length;
+        }
+        /**
+         * Purges cache entries.
+         * If `count` is specified, evicts up to `count` oldest non-static entries.
+         * If omitted, clears all entries, including static entries.
+         *
+         * @param count - Optional number of entries to evict. If omitted, clears all entries.
+         */
+        clear(count) {
+          if (count === void 0) {
+            this.#staticKeys.clear();
+            this.#expires.clear();
+            this.#ttls.clear();
+            super.clear();
+            return;
+          }
+          let evicted = 0;
+          for (const key of super.keys()) {
+            if (evicted >= count)
+              break;
+            if (!this.#staticKeys.has(key)) {
+              this.delete(key);
+              evicted++;
+            }
+          }
+        }
+        /**
+         * Returns an iterator of cache keys after evicting expired entries.
+         *
+         * @returns Iterator of cache keys
+         */
+        keys() {
+          this.evictExpired();
+          return super.keys();
+        }
+        /**
+         * Returns an iterator of cache values after evicting expired entries.
+         *
+         * @returns Iterator of cache values
+         */
+        values() {
+          this.evictExpired();
+          return super.values();
+        }
+        /**
+         * Returns an iterator of cache entries after evicting expired entries.
+         *
+         * @returns Iterator of [key, value] pairs
+         */
+        entries() {
+          this.evictExpired();
+          return super.entries();
+        }
+        /**
+         * Returns an iterator of cache entries after evicting expired entries, making the cache iterable.
+         *
+         * @returns Iterator of [key, value] pairs
+         */
+        [Symbol.iterator]() {
+          this.evictExpired();
+          return super[Symbol.iterator]();
+        }
+        /**
+         * Returns a plain key-value object of all active non-expired cache entries.
+         * Filters out non-string keys to prevent lossy key conversions or collisions (e.g. numeric 1 vs string "1").
+         */
+        toJSON() {
+          this.evictExpired();
+          const stringEntries = [];
+          for (const [k, v] of super.entries()) {
+            if (isString(k))
+              stringEntries.push([k, v]);
+          }
+          return Object.fromEntries(stringEntries);
+        }
+        /**
+         * Creates a BoundedCache from an iterable of key-value pairs.
+         *
+         * @param entries - Iterable of [key, value] pairs to populate the cache
+         * @param maxSize - Maximum number of entries (default: 1000)
+         * @param ttl - Time-to-live in milliseconds (default: 24 hours)
+         * @returns A new BoundedCache instance
+         */
+        static fromEntries(entries, maxSize = 1e3, ttl = 24 * 60 * 60 * 1e3) {
+          const cache = new BoundedCache2(maxSize, ttl);
+          for (const [k, v] of entries) {
+            cache.set(k, v);
+          }
+          return cache;
+        }
+      };
+      return BoundedCache2 = _classThis;
+    })();
+  }
+});
+
+// ../../library/dist/common/runtime/storage.library.js
+function getStorage(key, dflt) {
+  let store;
+  if (isUndefined(key))
+    return dflt ?? {};
+  switch (context.type) {
+    case CONTEXT.Browser:
+      store = storage.getItem(key);
+      break;
+    case CONTEXT.NodeJS:
+      store = nodeStorage.has(key) ? nodeStorage.get(key) : getEnvVar(key);
+      break;
+    case CONTEXT.Deno:
+      store = context.global.Deno.env.get(key);
+      break;
+    case CONTEXT.GoogleAppsScript:
+      store = context.global.PropertiesService?.getUserProperties().getProperty(key);
+      break;
+    case CONTEXT.WebWorker:
+    case CONTEXT.Unknown:
+      store = void 0;
+      break;
+    default:
+      throw new Error(`Cannot determine Javascript context: ${context.type}`);
+  }
+  return isString(store) ? objectify(store) : dflt;
+}
+function setStorage(key, val, options) {
+  const stash = isDefined(val) ? stringify(val) : void 0;
+  const set = isDefined(stash);
+  switch (context.type) {
+    case CONTEXT.Browser:
+      try {
+        set ? storage.setItem(key, stash) : storage.removeItem(key);
+      } catch (e) {
+        console.warn(`[Storage] Failed to ${set ? "setItem" : "removeItem"} for key '${key}':`, e);
+      }
+      break;
+    case CONTEXT.NodeJS:
+      if (!set) {
+        nodeStorage.set(key, void 0, options?.ttl);
+      } else if (options?.static) {
+        nodeStorage.setStatic(key, stash);
+      } else {
+        nodeStorage.set(key, stash, options?.ttl);
+      }
+      break;
+    case CONTEXT.Deno:
+      set ? context.global.Deno.env.set(key, stash) : context.global.Deno.env.delete(key);
+      break;
+    case CONTEXT.GoogleAppsScript:
+      set ? context.global.PropertiesService?.getUserProperties().setProperty(key, stash) : context.global.PropertiesService?.getUserProperties().deleteProperty(key);
+      break;
+    case CONTEXT.WebWorker:
+    case CONTEXT.Unknown:
+      break;
+    default:
+      throw new Error(`Cannot determine Javascript context: ${context.type}`);
+  }
+}
+var context, createMemoryStorage, memoryStores, getMemoryStorage, getSafeStorage, storage, nodeStorage, getEnvVar;
+var init_storage_library = __esm({
+  "../../library/dist/common/runtime/storage.library.js"() {
+    "use strict";
+    init_serialize_library();
+    init_utility_library();
+    init_assertion_library();
+    init_cache_class();
+    context = getContext();
+    createMemoryStorage = (maxSize = 1e3, ttl = Infinity) => {
+      const map = new BoundedCache(maxSize, ttl);
+      return {
+        get length() {
+          return map.size;
+        },
+        clear: () => map.clear(),
+        getItem: (key) => map.get(key) ?? null,
+        key: (index) => Array.from(map.keys())[index] ?? null,
+        removeItem: (key) => {
+          map.delete(key);
+        },
+        setItem: (key, value2) => {
+          map.set(key, String(value2));
+        }
+      };
+    };
+    memoryStores = /* @__PURE__ */ new Map();
+    getMemoryStorage = (name) => {
+      let store = memoryStores.get(name);
+      if (!store) {
+        store = createMemoryStorage();
+        memoryStores.set(name, store);
+      }
+      return store;
+    };
+    getSafeStorage = (name = "localStorage") => {
+      try {
+        const target = globalThis?.[name];
+        if (target && isCallable(target.getItem) && isCallable(target.setItem) && isCallable(target.removeItem) && isCallable(target.clear) && isCallable(target.key) && isNumber(target.length))
+          return target;
+      } catch {
+      }
+      return getMemoryStorage(name);
+    };
+    storage = context.type === CONTEXT.Browser ? getSafeStorage() : createMemoryStorage();
+    nodeStorage = new BoundedCache(1e3, Infinity);
+    getEnvVar = (key) => {
+      try {
+        const proc = Reflect.get(context.global, "process");
+        if (!proc || typeof proc !== "object")
+          return void 0;
+        const env = Reflect.get(proc, "env");
+        if (!env || typeof env !== "object")
+          return void 0;
+        return Reflect.get(env, key);
+      } catch {
+        return void 0;
+      }
+    };
   }
 });
 
@@ -867,6 +1595,10 @@ var init_string_library = __esm({
 });
 
 // ../../library/dist/common/primitives/coercion.library.js
+function asArray(arr = [], fill) {
+  const mapFn = (val) => isUndefined(fill) || isDefined(val) ? val : clone(fill);
+  return isArrayLike(arr) || isIterable(arr) && !isString(arr) ? Array.from(arr, mapFn) : [arr];
+}
 function asError(err) {
   if (isError(err))
     return err;
@@ -934,169 +1666,223 @@ var init_temporal_library = __esm({
 });
 
 // ../../library/dist/common/runtime/international.library.js
-function getDateTimeFormat() {
-  return getDTF().resolvedOptions();
-}
-function getHemisphere(timeZone = getDateTimeFormat().timeZone) {
-  try {
-    const { jan, jul } = getOffsets(timeZone);
-    const southPrefixes = ["Australia", "Antarctica", "Africa/Johannesburg", "America/Argentina/Buenos_Aires", "America/Sao_Paulo"];
-    const isSouthZone = southPrefixes.some((p) => timeZone.startsWith(p));
-    switch (true) {
-      case jul > jan:
-        return "north";
-      case jul < jan:
-        return "south";
-      default:
-        return isSouthZone ? "south" : void 0;
-    }
-  } catch (e) {
+function getPropOrCall(obj, method, fallbackProp) {
+  if (!obj)
     return void 0;
-  }
+  if (isCallable(obj[method]))
+    return obj[method]();
+  if (fallbackProp && fallbackProp in obj)
+    return obj[fallbackProp];
+  return void 0;
+}
+function getFallbackFirstDay(region) {
+  if (!region)
+    return 1;
+  if (FRIDAY_START_REGIONS.has(region))
+    return 5;
+  if (SATURDAY_START_REGIONS.has(region))
+    return 6;
+  if (SUNDAY_START_REGIONS.has(region))
+    return 7;
+  return 1;
 }
-var getRTF, getLF, getDTF, getPR, getNF, getDF;
+function getFallbackWeekend(region) {
+  if (!region)
+    return WEEKEND_SAT_SUN;
+  if (region === "IR")
+    return WEEKEND_FRI;
+  if (region === "AF")
+    return WEEKEND_THU_FRI;
+  if (FRI_SAT_WEEKEND_REGIONS.has(region))
+    return WEEKEND_FRI_SAT;
+  return WEEKEND_SAT_SUN;
+}
+function getFallbackDirection(loc, language) {
+  const script = loc?.script ?? (isCallable(loc?.maximize) ? loc.maximize().script : void 0);
+  return script && RTL_SCRIPTS.has(script) || language && RTL_LANGUAGES.has(language) ? "rtl" : "ltr";
+}
+var RE_UNDERSCORE, RE_LOCALE_CLEANSE, hasIntl, cleanLocaleTag, getRTF, getLF, getDTF, getPR, getNF, getDF, SUNDAY_START_REGIONS, SATURDAY_START_REGIONS, FRIDAY_START_REGIONS, FRI_SAT_WEEKEND_REGIONS, RTL_LANGUAGES, RTL_SCRIPTS, WEEKEND_SAT_SUN, WEEKEND_FRI_SAT, WEEKEND_FRI, WEEKEND_THU_FRI, getLC, getLI, getDigitsMap, FALLBACK_DTF_OPTIONS, getDateTimeFormat, canonicalLocale, canonicalLocales, getHemisphere, probeMDY;
 var init_international_library = __esm({
   "../../library/dist/common/runtime/international.library.js"() {
     "use strict";
     init_temporal_library();
     init_function_library();
     init_assertion_library();
-    getRTF = memoizeFunction((locale, style = "narrow", numeric = "always") => {
-      return new Intl.RelativeTimeFormat(locale, { style, numeric });
+    init_coercion_library();
+    RE_UNDERSCORE = /_/g;
+    RE_LOCALE_CLEANSE = /[.@]/;
+    hasIntl = (feature) => typeof Intl !== "undefined" && (!feature || Object.hasOwn(Intl, feature) && isCallable(Intl[feature]));
+    cleanLocaleTag = (tag2) => {
+      if (isLocale(tag2))
+        tag2 = tag2.toString();
+      if (!isString(tag2))
+        return void 0;
+      const trimmed = tag2.trim();
+      if (isEmpty(trimmed))
+        return void 0;
+      const stripped = trimmed.split(RE_LOCALE_CLEANSE)[0];
+      if (isEmpty(stripped))
+        return void 0;
+      return stripped.replace(RE_UNDERSCORE, "-");
+    };
+    getRTF = memoizeFunction((locale, options) => {
+      return new Intl.RelativeTimeFormat(cleanLocaleTag(locale), options);
     });
-    getLF = memoizeFunction((locale, type = "conjunction", style = "long") => {
-      return new Intl.ListFormat(locale, { type, style });
+    getLF = memoizeFunction((locale, options) => {
+      return new Intl.ListFormat(cleanLocaleTag(locale), options);
     });
     getDTF = memoizeFunction((locale, options) => {
-      return new Intl.DateTimeFormat(locale, options);
+      return new Intl.DateTimeFormat(cleanLocaleTag(locale), options);
     });
     getPR = memoizeFunction((locale, options) => {
       try {
-        return new Intl.PluralRules(locale, options);
+        return new Intl.PluralRules(cleanLocaleTag(locale), options);
       } catch (e) {
         return { select: () => "other" };
       }
     });
-    getNF = memoizeFunction((locale, options) => {
-      return new Intl.NumberFormat(locale, options);
+    getNF = memoizeFunction((locale, options) => {
+      return new Intl.NumberFormat(cleanLocaleTag(locale), options);
+    });
+    getDF = memoizeFunction((locale, options) => {
+      try {
+        const df = new Intl.DurationFormat(cleanLocaleTag(locale), options);
+        if (isFunction(df.format))
+          return df;
+        throw new Error("No format method");
+      } catch (e) {
+        return { format: (duration) => String(duration) };
+      }
+    });
+    SUNDAY_START_REGIONS = /* @__PURE__ */ new Set(["US", "CA", "MX", "BR", "IL", "JP", "TW", "HK", "MO", "PH", "SG", "TH", "IN", "KR", "CO", "PE", "VE", "ZA"]);
+    SATURDAY_START_REGIONS = /* @__PURE__ */ new Set(["SA", "AF", "BH", "DJ", "DZ", "EG", "IQ", "IR", "JO", "KW", "LY", "OM", "QA", "SD", "SY", "YE"]);
+    FRIDAY_START_REGIONS = /* @__PURE__ */ new Set(["MV"]);
+    FRI_SAT_WEEKEND_REGIONS = /* @__PURE__ */ new Set(["SA", "BH", "DJ", "DZ", "EG", "IQ", "JO", "KW", "LY", "OM", "QA", "SD", "SY", "YE"]);
+    RTL_LANGUAGES = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur", "yi", "ps", "sd", "ug", "ckb"]);
+    RTL_SCRIPTS = /* @__PURE__ */ new Set(["Arab", "Hebr", "Thaa", "Syrc", "Mand", "Samr", "Nkoo"]);
+    WEEKEND_SAT_SUN = Object.freeze([6, 7]);
+    WEEKEND_FRI_SAT = Object.freeze([5, 6]);
+    WEEKEND_FRI = Object.freeze([5]);
+    WEEKEND_THU_FRI = Object.freeze([4, 5]);
+    getLC = memoizeFunction((localeTag) => {
+      if (isLocale(localeTag))
+        return localeTag;
+      if (!hasIntl("Locale"))
+        return void 0;
+      try {
+        const cleaned = cleanLocaleTag(localeTag);
+        return new Intl.Locale(cleaned || "en-US");
+      } catch {
+        return void 0;
+      }
+    });
+    getLI = memoizeFunction((localeTag) => {
+      const loc = getLC(localeTag) ?? getLC("en-US");
+      const baseName = loc?.baseName ?? canonicalLocale(localeTag) ?? "en-US";
+      const language = loc?.language ?? baseName.split("-")[0]?.toLowerCase();
+      const regionSubtags = [];
+      for (const sub of baseName.split("-").slice(1)) {
+        if (sub.length === 1)
+          break;
+        regionSubtags.push(sub);
+      }
+      const region = loc?.region ?? (isCallable(loc?.maximize) ? loc.maximize().region : void 0) ?? regionSubtags.find((subtag) => /^[a-zA-Z]{2}$|^\d{3}$/.test(subtag))?.toUpperCase();
+      const script = loc?.script ?? (isCallable(loc?.maximize) ? loc.maximize().script : void 0);
+      const rawWeek = getPropOrCall(loc, "getWeekInfo", "weekInfo");
+      const firstDay = rawWeek?.firstDay ?? getFallbackFirstDay(region);
+      const weekend = Array.isArray(rawWeek?.weekend) ? Object.freeze([...rawWeek.weekend]) : getFallbackWeekend(region);
+      const rawCycles = getPropOrCall(loc, "getHourCycles", "hourCycles") ?? loc?.hourCycle;
+      const resolvedHc = rawCycles ?? (hasIntl("DateTimeFormat") ? getDTF(baseName, { hour: "numeric" }).resolvedOptions().hourCycle : void 0);
+      const hourCycles = Array.isArray(resolvedHc) && resolvedHc.length > 0 ? Object.freeze([...resolvedHc]) : isString(resolvedHc) ? Object.freeze([resolvedHc]) : Object.freeze(["h23"]);
+      const rawText = getPropOrCall(loc, "getTextInfo", "textInfo");
+      const direction = rawText?.direction === "rtl" || rawText?.direction === "ltr" ? rawText.direction : getFallbackDirection(loc, language);
+      const rawSystems = getPropOrCall(loc, "getNumberingSystems", "numberingSystems") ?? loc?.numberingSystem;
+      const resolvedNs = rawSystems ?? (hasIntl("NumberFormat") ? getNF(baseName).resolvedOptions().numberingSystem : void 0);
+      const numberingSystems = Array.isArray(resolvedNs) && resolvedNs.length > 0 ? Object.freeze([...resolvedNs]) : isString(resolvedNs) ? Object.freeze([resolvedNs]) : Object.freeze(["latn"]);
+      const rawTimeZones = getPropOrCall(loc, "getTimeZones", "timeZones");
+      const timeZones = Array.isArray(rawTimeZones) && rawTimeZones.length > 0 ? Object.freeze([...rawTimeZones]) : Object.freeze([]);
+      const weekInfo = Object.freeze({ firstDay, weekend });
+      return Object.freeze({
+        locale: loc,
+        baseName,
+        language,
+        region,
+        script,
+        weekInfo,
+        firstDay,
+        weekend,
+        hourCycle: hourCycles[0],
+        hourCycles,
+        direction,
+        numberingSystem: numberingSystems[0],
+        numberingSystems,
+        timeZones
+      });
+    });
+    getDigitsMap = memoizeFunction((numberingSystem = "latn") => {
+      if (!numberingSystem || numberingSystem === "latn" || !hasIntl("NumberFormat"))
+        return void 0;
+      try {
+        const nf = new Intl.NumberFormat(`en-u-nu-${numberingSystem}`, { useGrouping: false });
+        const digits = Array.from({ length: 10 }, (_, i) => nf.format(i));
+        if (digits[0] === "0" && digits[9] === "9")
+          return void 0;
+        return Object.freeze(digits);
+      } catch {
+        return void 0;
+      }
+    });
+    FALLBACK_DTF_OPTIONS = Object.freeze({
+      locale: "en-US",
+      calendar: "iso8601",
+      numberingSystem: "latn",
+      timeZone: "UTC"
+    });
+    getDateTimeFormat = memoizeFunction(() => {
+      return hasIntl("DateTimeFormat") ? Object.freeze(getDTF().resolvedOptions()) : FALLBACK_DTF_OPTIONS;
+    });
+    canonicalLocale = memoizeFunction((locale) => {
+      const cleaned = cleanLocaleTag(locale);
+      if (!cleaned)
+        return void 0;
+      if (hasIntl("getCanonicalLocales")) {
+        try {
+          return Intl.getCanonicalLocales(cleaned)[0];
+        } catch {
+          return void 0;
+        }
+      }
+      return getLC(cleaned)?.baseName ?? cleaned;
+    });
+    canonicalLocales = memoizeFunction((locales) => {
+      return Object.freeze(asArray(locales).map((l) => canonicalLocale(l)).filter(Boolean));
     });
-    getDF = memoizeFunction((locale, options) => {
+    getHemisphere = memoizeFunction((timeZone = getDateTimeFormat().timeZone) => {
       try {
-        const df = new Intl.DurationFormat(locale, options);
-        if (isFunction(df.format))
-          return df;
-        throw new Error("No format method");
+        const { jan, jul } = getOffsets(timeZone);
+        const southPrefixes = ["Australia", "Antarctica", "Africa/Johannesburg", "America/Argentina/Buenos_Aires", "America/Sao_Paulo"];
+        const isSouthZone = southPrefixes.some((p) => timeZone.startsWith(p));
+        switch (true) {
+          case jul > jan:
+            return "north";
+          case jul < jan:
+            return "south";
+          default:
+            return isSouthZone ? "south" : void 0;
+        }
       } catch (e) {
-        return { format: (duration) => String(duration) };
+        return void 0;
       }
     });
-  }
-});
-
-// ../../../node_modules/tslib/tslib.es6.mjs
-function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-  function accept(f) {
-    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
-    return f;
-  }
-  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-  var _, done = false;
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    var context3 = {};
-    for (var p in contextIn) context3[p] = p === "access" ? {} : contextIn[p];
-    for (var p in contextIn.access) context3.access[p] = contextIn.access[p];
-    context3.addInitializer = function(f) {
-      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
-      extraInitializers.push(accept(f || null));
-    };
-    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context3);
-    if (kind === "accessor") {
-      if (result === void 0) continue;
-      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-      if (_ = accept(result.get)) descriptor.get = _;
-      if (_ = accept(result.set)) descriptor.set = _;
-      if (_ = accept(result.init)) initializers.unshift(_);
-    } else if (_ = accept(result)) {
-      if (kind === "field") initializers.unshift(_);
-      else descriptor[key] = _;
-    }
-  }
-  if (target) Object.defineProperty(target, contextIn.name, descriptor);
-  done = true;
-}
-function __runInitializers(thisArg, initializers, value2) {
-  var useValue = arguments.length > 2;
-  for (var i = 0; i < initializers.length; i++) {
-    value2 = useValue ? initializers[i].call(thisArg, value2) : initializers[i].call(thisArg);
-  }
-  return useValue ? value2 : void 0;
-}
-var init_tslib_es6 = __esm({
-  "../../../node_modules/tslib/tslib.es6.mjs"() {
-    "use strict";
-  }
-});
-
-// ../../library/dist/common/runtime/decorator.library.js
-function getClassName(value2, contextName) {
-  return getSafeTag(value2) ?? (isUndefined(contextName) ? value2.name || void 0 : String(contextName));
-}
-function Serializable(value2, { kind, name, addInitializer }) {
-  const finalName = getClassName(value2, name);
-  if (finalName)
-    registerType(value2, finalName);
-  switch (kind) {
-    case "class":
-      if (finalName)
-        addInitializer(() => registerSerializable(finalName, value2));
-      return value2;
-    default:
-      throw new Error(`@Serializable decorating unknown 'kind': ${kind} (${name})`);
-  }
-}
-function StringTag(tagOrValue, context3) {
-  const applyTag = (value2, customTag, contextName) => {
-    const proto = value2.prototype;
-    const tagName = customTag ?? getClassName(value2, contextName);
-    if (tagName) {
-      if (proto && !Object.hasOwn(proto, Symbol.toStringTag)) {
-        Object.defineProperty(proto, Symbol.toStringTag, {
-          value: tagName,
-          configurable: true,
-          writable: false,
-          enumerable: false
-        });
-      }
-      if (!value2.name || value2.name !== tagName) {
-        try {
-          Object.defineProperty(value2, "name", {
-            value: tagName,
-            configurable: true,
-            writable: false,
-            enumerable: false
-          });
-        } catch {
-        }
+    probeMDY = memoizeFunction((locale) => {
+      try {
+        const date = new Date(2024, 11, 24);
+        const parts = getDTF(locale).formatToParts(date);
+        return parts[0].type === "month" && parts[0].value === "12";
+      } catch {
+        return false;
       }
-    }
-    return value2;
-  };
-  if (typeof tagOrValue === "function" && context3?.kind === "class")
-    return applyTag(tagOrValue, void 0, context3.name);
-  return (value2, ctx) => {
-    return applyTag(value2, isString(tagOrValue) ? tagOrValue : void 0, ctx?.name);
-  };
-}
-var init_decorator_library = __esm({
-  "../../library/dist/common/runtime/decorator.library.js"() {
-    "use strict";
-    init_symbol_library();
-    init_proxy_library();
-    init_assertion_library();
-    init_serialize_library();
-    init_type_library();
+    });
   }
 });
 
@@ -1329,54 +2115,6 @@ var init_logger_class = __esm({
   }
 });
 
-// ../../library/dist/common/runtime/storage.library.js
-var context, createMemoryStorage, memoryStores, getMemoryStorage, getSafeStorage, storage;
-var init_storage_library = __esm({
-  "../../library/dist/common/runtime/storage.library.js"() {
-    "use strict";
-    init_serialize_library();
-    init_utility_library();
-    init_assertion_library();
-    context = getContext();
-    createMemoryStorage = () => {
-      const map = /* @__PURE__ */ new Map();
-      return {
-        get length() {
-          return map.size;
-        },
-        clear: () => map.clear(),
-        getItem: (key) => map.get(key) ?? null,
-        key: (index) => Array.from(map.keys())[index] ?? null,
-        removeItem: (key) => {
-          map.delete(key);
-        },
-        setItem: (key, value2) => {
-          map.set(key, String(value2));
-        }
-      };
-    };
-    memoryStores = /* @__PURE__ */ new Map();
-    getMemoryStorage = (name) => {
-      let store = memoryStores.get(name);
-      if (!store) {
-        store = createMemoryStorage();
-        memoryStores.set(name, store);
-      }
-      return store;
-    };
-    getSafeStorage = (name = "localStorage") => {
-      try {
-        const target = globalThis?.[name];
-        if (target && typeof target.getItem === "function" && typeof target.setItem === "function" && typeof target.removeItem === "function" && typeof target.clear === "function" && typeof target.key === "function" && typeof target.length === "number")
-          return target;
-      } catch {
-      }
-      return getMemoryStorage(name);
-    };
-    storage = context.type === CONTEXT.Browser ? getSafeStorage() : createMemoryStorage();
-  }
-});
-
 // ../../library/dist/browser/webstore.class.js
 var webstore_class_exports = {};
 __export(webstore_class_exports, {
@@ -1622,7 +2360,7 @@ var init_mapper_library = __esm({
     defaults = { catch: true, debug: 0 };
     context2 = getContext();
     mapStore = {};
-    MAP_KEY = "_map_";
+    MAP_KEY = "_magma_browser_map_";
     log = new Logger("[Mapper]");
     storePromise = null;
     getStore = () => {
@@ -1631,7 +2369,12 @@ var init_mapper_library = __esm({
           if (context2.type === CONTEXT.Browser) {
             Promise.resolve().then(() => (init_webstore_class(), webstore_class_exports)).then(({ WebStore: WebStore2 }) => {
               const local = new WebStore2("local");
-              Object.assign(mapStore, local.get(MAP_KEY, {}));
+              const stashed = local.get(MAP_KEY, {});
+              if (isReference(stashed)) {
+                if (stashed.geolocation && (!stashed.geolocation.coords || stashed.geolocation.$GeolocationPosition))
+                  delete stashed.geolocation;
+                Object.assign(mapStore, stashed);
+              }
               resolve(local);
             }).catch(reject);
           } else {
@@ -1685,7 +2428,7 @@ var init_mapper_library = __esm({
       const fulfil = opts.catch ? resolve : reject;
       geoCoords(coords).then((loc) => {
         switch (true) {
-          case !(typeof window !== "undefined" && "google" in window && "maps" in window["google"]):
+          case (context2.type !== CONTEXT.Browser || !window["google"]?.maps):
             throw new Error("Google Maps API not configured");
           case isNullish(loc):
             throw new Error("Cannot determine Coordinates");
@@ -1929,7 +2672,7 @@ __export(mapper_library_exports2, {
   serverGeoLocation: () => serverGeoLocation,
   serverMapHemisphere: () => serverMapHemisphere
 });
-var log2, defaults2, requestModulePromise, getRequestModule, serverGeoLocation, serverGeoCoords, serverMapHemisphere;
+var log2, DEFAULT_GEO_ENDPOINT, defaults2, requestModulePromise, getRequestModule, serverGeoLocation, serverGeoCoords, serverMapHemisphere;
 var init_mapper_library2 = __esm({
   "../../library/dist/server/mapper.library.js"() {
     "use strict";
@@ -1937,8 +2680,9 @@ var init_mapper_library2 = __esm({
     init_international_library();
     init_logger_class();
     log2 = new Logger("[ServerMapper]");
+    DEFAULT_GEO_ENDPOINT = "https://ipwho.is";
     defaults2 = {
-      endpoint: "https://ipwho.is/",
+      endpoint: `${DEFAULT_GEO_ENDPOINT}/`,
       timeout: 3e3,
       catch: true,
       debug: 0
@@ -1953,7 +2697,18 @@ var init_mapper_library2 = __esm({
       const options = { ...defaults2, ...opts };
       const fulfil = options.catch !== false;
       try {
-        const endpoint = options.endpoint || defaults2.endpoint;
+        let endpoint = options.endpoint || defaults2.endpoint;
+        if (isString(options.ip)) {
+          const cleanIp = encodeURIComponent(options.ip.trim());
+          const normalized = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+          if (normalized === DEFAULT_GEO_ENDPOINT) {
+            endpoint = `${DEFAULT_GEO_ENDPOINT}/${cleanIp}`;
+          } else if (endpoint.includes("{ip}")) {
+            endpoint = endpoint.replace("{ip}", cleanIp);
+          } else if (cleanIp !== "") {
+            throw new Error(`Custom endpoint must include an '{ip}' placeholder to resolve a specific IP: ${endpoint}`);
+          }
+        }
         const timeout = options.timeout ?? defaults2.timeout;
         const { fetchRequest: fetchRequest2 } = await getRequestModule();
         const data = await fetchRequest2(endpoint, {}, { ...isNumber(timeout) ? { timeout } : {}, maxBytes: 64 * 1024 });
@@ -2019,145 +2774,486 @@ __export(sdk_exports, {
 __reExport(sdk_exports, sdk_star);
 import * as sdk_star from "@magmacomputing/tempo/plugin/sdk";
 import { definePlugin as originalPlugin, defineTerm as originalTerm } from "@magmacomputing/tempo/plugin/sdk";
-var definePlugin = (config) => originalPlugin({ ...config, version: "0.1.0" });
-var defineTerm = (config) => originalTerm({ ...config, version: "0.1.0" });
+var definePlugin = (config) => originalPlugin({ ...config, version: "1.1.0" });
+var defineTerm = (config) => originalTerm({ ...config, version: "1.1.0" });
 
 // ../../library/dist/common/runtime/mapper.library.js
 init_utility_library();
 init_assertion_library();
+init_storage_library();
+
+// ../../library/dist/common/runtime/evaluation.library.js
+init_assertion_library();
+function evaluate(...values) {
+  for (const val of values) {
+    const resolved = isFunction(val) ? val() : val;
+    if (resolved !== void 0)
+      return resolved;
+  }
+  return void 0;
+}
+
+// ../../library/dist/common/runtime/mapper.library.js
+var MAP_KEY2 = "_magma_geo_";
+var DEFAULT_GEO_TTL = 24 * 60 * 60 * 1e3;
+var GEO_PROPERTIES = [
+  "latitude",
+  "lat",
+  "longitude",
+  "lng",
+  "lon",
+  "long",
+  "elevation",
+  "sphere",
+  "country",
+  "city",
+  "timezone",
+  "tz"
+];
+var normalizeLat = (lat) => isNumber(lat) && lat >= -90 && lat <= 90 ? Math.round(lat * 1e3) / 1e3 : void 0;
+var normalizeLng = (lng) => isNumber(lng) && lng >= -180 && lng <= 180 ? Math.round(lng * 1e3) / 1e3 : void 0;
+var normalizeCoords = (lat, lng) => {
+  const nLat = normalizeLat(lat);
+  const nLng = normalizeLng(lng);
+  return nLat !== void 0 && nLng !== void 0 ? { lat: nLat, lng: nLng } : void 0;
+};
+var resolveSphere = (sphere, lat) => {
+  if (sphere === "north" || sphere === "south" || sphere === "equator")
+    return sphere;
+  if (isNumber(lat))
+    return lat > 1e-3 ? "north" : lat < -1e-3 ? "south" : "equator";
+  return void 0;
+};
 var coerceGeo = (input) => {
-  if (isNullish(input) || typeof input !== "object")
+  if (isString(input) && input.includes(",")) {
+    const segments = input.split(",").map((s) => s.trim());
+    const parts = segments.map((s) => s === "" ? NaN : Number(s));
+    if (parts.length >= 2 && !isNaN(parts[0]) && !isNaN(parts[1])) {
+      const coords = normalizeCoords(parts[0], parts[1]);
+      if (coords) {
+        const result2 = { latitude: coords.lat, longitude: coords.lng };
+        const sphere2 = resolveSphere(void 0, coords.lat);
+        if (sphere2)
+          result2.sphere = sphere2;
+        return result2;
+      }
+    }
+    return void 0;
+  }
+  if (isPrimitive(input))
+    return void 0;
+  if (Array.isArray(input) && input.length >= 2) {
+    const coords = normalizeCoords(input[0], input[1]);
+    if (coords) {
+      const result2 = { latitude: coords.lat, longitude: coords.lng };
+      const sphere2 = resolveSphere(void 0, coords.lat);
+      if (sphere2)
+        result2.sphere = sphere2;
+      return result2;
+    }
     return void 0;
-  const geoObj = input.geo ?? input;
-  const cfgGeo = input.config?.geo ?? input.config;
-  const lat = geoObj?.latitude ?? geoObj?.lat ?? input.latitude ?? input.lat ?? cfgGeo?.latitude ?? cfgGeo?.lat;
-  const lng = geoObj?.longitude ?? geoObj?.lng ?? geoObj?.lon ?? geoObj?.long ?? input.longitude ?? input.lng ?? input.lon ?? input.long ?? cfgGeo?.longitude ?? cfgGeo?.lng ?? cfgGeo?.lon ?? cfgGeo?.long;
-  const elevation = geoObj?.elevation ?? input.elevation ?? cfgGeo?.elevation;
-  const sphere = geoObj?.sphere ?? input.sphere ?? cfgGeo?.sphere;
-  const country = geoObj?.country ?? input.country ?? cfgGeo?.country;
-  const city = geoObj?.city ?? input.city ?? cfgGeo?.city;
+  }
+  const geo = input.geo ?? input;
+  const cfg = input.config?.geo ?? input.config;
+  const lat = evaluate(geo?.latitude, geo?.lat, input.latitude, input.lat, cfg?.latitude, cfg?.lat);
+  const lng = evaluate(geo?.longitude, geo?.lng, geo?.lon, geo?.long, input.longitude, input.lng, input.lon, input.long, cfg?.longitude, cfg?.lng, cfg?.lon, cfg?.long);
+  const elevation = evaluate(geo?.elevation, input.elevation, cfg?.elevation);
+  const sphere = evaluate(geo?.sphere, input.sphere, cfg?.sphere);
+  const country = evaluate(geo?.country, input.country, cfg?.country);
+  const city = evaluate(geo?.city, input.city, cfg?.city);
+  const timezone = evaluate(geo?.timezone, geo?.tz, input.timezone, input.tz, cfg?.timezone, cfg?.tz);
   const result = {};
-  if (isNumber(lat))
-    result.latitude = lat;
-  if (isNumber(lng))
-    result.longitude = lng;
+  const nLat = normalizeLat(lat);
+  const nLng = normalizeLng(lng);
+  if (nLat !== void 0)
+    result.latitude = nLat;
+  if (nLng !== void 0)
+    result.longitude = nLng;
   if (isNumber(elevation))
-    result.elevation = elevation;
-  if (sphere === "north" || sphere === "south")
-    result.sphere = sphere;
+    result.elevation = Math.round(elevation * 1e3) / 1e3;
+  const resolvedSphere = resolveSphere(sphere, result.latitude);
+  if (resolvedSphere)
+    result.sphere = resolvedSphere;
   if (isString(country))
     result.country = country;
   if (isString(city))
     result.city = city;
-  if (geoObj && typeof geoObj === "object") {
-    for (const key of Object.keys(geoObj)) {
-      if (isSafeKey(key) && !["latitude", "lat", "longitude", "lng", "lon", "long", "elevation", "sphere", "country", "city"].includes(key))
-        result[key] = geoObj[key];
+  if (isString(timezone))
+    result.timezone = timezone;
+  const explicitGeo = isReference(input.geo) ? input.geo : isReference(input.config?.geo) ? input.config.geo : void 0;
+  if (isReference(explicitGeo)) {
+    for (const key of Object.keys(explicitGeo)) {
+      if (isSafeKey(key) && !GEO_PROPERTIES.includes(key))
+        result[key] = explicitGeo[key];
     }
   }
   return Object.keys(result).length > 0 ? result : void 0;
 };
-var getStashedGeo = () => {
-  const { type } = getContext();
-  if (type === CONTEXT.Browser || type === CONTEXT.WebWorker) {
-    try {
-      if (typeof localStorage !== "undefined") {
-        const raw = localStorage.getItem("_map_");
-        if (raw) {
-          const parsed = JSON.parse(raw);
-          const coords = parsed?.geolocation?.coords;
-          if (isNumber(coords?.latitude) && isNumber(coords?.longitude)) {
-            return { latitude: coords.latitude, longitude: coords.longitude };
-          }
-        }
+var resolveCacheKey = (keyOrOpts) => {
+  if (isString(keyOrOpts) && !isEmpty(keyOrOpts)) {
+    const trimmed = keyOrOpts.trim();
+    return trimmed.startsWith(MAP_KEY2) ? trimmed : `${MAP_KEY2}:${trimmed}`;
+  }
+  if (keyOrOpts && isObject(keyOrOpts)) {
+    const k = keyOrOpts.key ?? keyOrOpts.ip ?? keyOrOpts.query;
+    if (isString(k) && !isEmpty(k))
+      return `${MAP_KEY2}:${k.trim()}`;
+  }
+  return MAP_KEY2;
+};
+var getStashedGeo = (keyOrOpts) => {
+  const cacheKey = resolveCacheKey(keyOrOpts);
+  try {
+    const raw = getStorage(cacheKey) ?? (typeof localStorage !== "undefined" ? localStorage.getItem(cacheKey) : void 0);
+    if (!raw)
+      return void 0;
+    const parsed = isString(raw) && (raw.startsWith("{") || raw.startsWith("[")) ? JSON.parse(raw) : raw;
+    if (isObject(parsed)) {
+      if (isNumber(parsed._expires) && Date.now() > parsed._expires) {
+        clearStashedGeo(keyOrOpts);
+        return void 0;
+      }
+    }
+    if (isString(parsed) && parsed.includes(",")) {
+      const parts = parsed.split(",").map((s) => parseFloat(s.trim()));
+      const coords = normalizeCoords(parts[0], parts[1]);
+      if (coords) {
+        return {
+          latitude: coords.lat,
+          longitude: coords.lng,
+          sphere: resolveSphere(void 0, coords.lat)
+        };
+      }
+    }
+    if (isObject(parsed)) {
+      const rawCoords = parsed.geolocation?.coords ?? parsed.coords ?? parsed;
+      const lat = rawCoords?.latitude ?? rawCoords?.lat;
+      const lng = rawCoords?.longitude ?? rawCoords?.lng ?? rawCoords?.lon ?? rawCoords?.long;
+      const coords = normalizeCoords(lat, lng);
+      if (coords) {
+        const result = { latitude: coords.lat, longitude: coords.lng };
+        const elevation = parsed.elevation ?? rawCoords.elevation;
+        if (isNumber(elevation))
+          result.elevation = Math.round(elevation * 1e3) / 1e3;
+        result.sphere = resolveSphere(parsed.sphere, coords.lat);
+        if (isString(parsed.country))
+          result.country = parsed.country;
+        if (isString(parsed.city))
+          result.city = parsed.city;
+        if (isString(parsed.timezone))
+          result.timezone = parsed.timezone;
+        return result;
       }
-    } catch {
     }
+  } catch {
   }
   return void 0;
 };
+var stashGeo = (coords, ttl = DEFAULT_GEO_TTL, keyOrOpts) => {
+  const cacheKey = resolveCacheKey(keyOrOpts);
+  const payload = isNumber(ttl) && ttl > 0 ? { ...coords, _expires: Date.now() + ttl } : coords;
+  setStorage(cacheKey, payload, { ttl });
+};
+var clearStashedGeo = (keyOrOpts) => {
+  const cacheKey = resolveCacheKey(keyOrOpts);
+  setStorage(cacheKey, void 0);
+};
 var geoLookup = async (opts = {}) => {
+  const useCache = opts.refresh !== true;
+  if (useCache) {
+    const stashed = getStashedGeo(opts);
+    if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude)) {
+      const { latitude, longitude, ...rest } = stashed;
+      return {
+        ...rest,
+        status: "cached",
+        lat: latitude,
+        lng: longitude,
+        latitude,
+        longitude
+      };
+    }
+  }
   const { type } = getContext();
+  let res;
   switch (type) {
     case CONTEXT.Browser: {
       const { geoLocation: geoLocation2 } = await Promise.resolve().then(() => (init_mapper_library(), mapper_library_exports));
-      const res = await geoLocation2(opts);
-      if (res.error)
-        return { error: res.error };
-      const lat = res.coords?.latitude;
-      const lng = res.coords?.longitude;
-      return { lat, lng, latitude: lat, longitude: lng, ...res };
-    }
-    case CONTEXT.WebWorker: {
-      const stashed = getStashedGeo();
-      if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude))
-        return { lat: stashed.latitude, lng: stashed.longitude, latitude: stashed.latitude, longitude: stashed.longitude };
-      const { serverGeoLocation: serverGeoLocation2 } = await Promise.resolve().then(() => (init_mapper_library2(), mapper_library_exports2));
-      return serverGeoLocation2(opts);
+      const browserRes = await geoLocation2(opts);
+      if (browserRes.error)
+        return { error: browserRes.error };
+      const lat = browserRes.coords?.latitude;
+      const lng = browserRes.coords?.longitude;
+      res = { ...browserRes, lat, lng, latitude: lat, longitude: lng };
+      break;
     }
+    case CONTEXT.WebWorker:
     case CONTEXT.NodeJS:
     case CONTEXT.Deno:
     default: {
       const { serverGeoLocation: serverGeoLocation2 } = await Promise.resolve().then(() => (init_mapper_library2(), mapper_library_exports2));
-      return serverGeoLocation2(opts);
+      res = await serverGeoLocation2(opts);
+      break;
+    }
+  }
+  const rawLat = res.latitude ?? res.lat;
+  const rawLng = res.longitude ?? res.lng;
+  const coords = normalizeCoords(rawLat, rawLng);
+  if (isNullish(res.error) && coords) {
+    const sphere = resolveSphere(res.sphere, coords.lat);
+    res.lat = coords.lat;
+    res.lng = coords.lng;
+    res.latitude = coords.lat;
+    res.longitude = coords.lng;
+    res.sphere = sphere;
+    const stashPayload = {
+      latitude: coords.lat,
+      longitude: coords.lng,
+      sphere,
+      ...isString(res.city) ? { city: res.city } : {},
+      ...isString(res.country) ? { country: res.country } : {},
+      ...isNumber(res.elevation) ? { elevation: Math.round(res.elevation * 1e3) / 1e3 } : {},
+      ...isString(res.timezone) ? { timezone: res.timezone } : {}
+    };
+    try {
+      const ttl = isNumber(opts.ttl) ? opts.ttl : DEFAULT_GEO_TTL;
+      stashGeo(stashPayload, ttl, opts);
+    } catch {
     }
   }
+  return res;
 };
 var resolveGeoCoordinates = async (input, opts = {}) => {
   const coerced = coerceGeo(input);
   if (coerced && isNumber(coerced.latitude) && isNumber(coerced.longitude))
-    return { lat: coerced.latitude, lng: coerced.longitude };
-  const stashed = getStashedGeo();
+    return {
+      ...coerced,
+      lat: coerced.latitude,
+      lng: coerced.longitude
+    };
+  const stashed = opts.refresh === true ? void 0 : getStashedGeo(opts);
   if (stashed && isNumber(stashed.latitude) && isNumber(stashed.longitude))
-    return { lat: stashed.latitude, lng: stashed.longitude };
+    return {
+      ...stashed,
+      lat: stashed.latitude,
+      lng: stashed.longitude
+    };
   const lookup = await geoLookup(opts);
-  if (isNullish(lookup.error) && isNumber(lookup.lat) && isNumber(lookup.lng))
-    return { lat: lookup.lat, lng: lookup.lng };
+  const coords = normalizeCoords(lookup.lat, lookup.lng);
+  if (isNullish(lookup.error) && coords) {
+    const sphere = resolveSphere(lookup.sphere, coords.lat);
+    return {
+      ...lookup,
+      lat: coords.lat,
+      lng: coords.lng,
+      latitude: coords.lat,
+      longitude: coords.lng,
+      sphere
+    };
+  }
   return null;
 };
+function haversineDistance(from, to, unit = "km") {
+  const c1 = coerceGeo(from);
+  const c2 = coerceGeo(to);
+  if (!c1 || !c2 || !isNumber(c1.latitude) || !isNumber(c1.longitude) || !isNumber(c2.latitude) || !isNumber(c2.longitude)) {
+    return NaN;
+  }
+  const toRad = Math.PI / 180;
+  const lat1 = c1.latitude * toRad;
+  const lng1 = c1.longitude * toRad;
+  const lat2 = c2.latitude * toRad;
+  const lng2 = c2.longitude * toRad;
+  const dLat = lat2 - lat1;
+  const dLng = lng2 - lng1;
+  const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  let radius;
+  if (unit === "miles") {
+    radius = 3958.7613;
+  } else if (unit === "m") {
+    radius = 63710088e-1;
+  } else {
+    radius = 6371.0088;
+  }
+  const dist = radius * c;
+  return unit === "m" ? Math.round(dist) : Math.round(dist * 1e3) / 1e3;
+}
+var resolveCivilTimezoneOffset = (tz, epochMs) => {
+  try {
+    if (typeof Temporal !== "undefined" && typeof Temporal.Instant?.fromEpochMilliseconds === "function") {
+      const zdt = Temporal.Instant.fromEpochMilliseconds(epochMs).toZonedDateTimeISO(tz);
+      return zdt.offsetNanoseconds / 6e10;
+    }
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      timeZoneName: "longOffset",
+      year: "numeric"
+    }).formatToParts(new Date(epochMs));
+    const tzPart = parts.find((p) => p.type === "timeZoneName")?.value;
+    if (tzPart) {
+      if (tzPart === "GMT" || tzPart === "UTC")
+        return 0;
+      const match = tzPart.match(/GMT([+-])(\d{2}):(\d{2})/);
+      if (match) {
+        const sign = match[1] === "-" ? -1 : 1;
+        return sign * (parseInt(match[2], 10) * 60 + parseInt(match[3], 10));
+      }
+    }
+  } catch {
+  }
+  return void 0;
+};
+function solarOffset(coords, options) {
+  const geo = coerceGeo(coords);
+  if (!geo || !isNumber(geo.latitude) || !isNumber(geo.longitude) || isNaN(geo.latitude) || isNaN(geo.longitude)) {
+    return NaN;
+  }
+  const lng = geo.longitude;
+  const tz = options?.timeZone ?? (isReference(coords) ? coords.timezone ?? coords.tz : void 0) ?? geo.timezone;
+  const dateVal = options?.date ?? (isReference(coords) && isNumber(coords.epoch?.ms) ? coords.epoch.ms : Date.now());
+  const epochMs = typeof dateVal === "number" ? dateVal : isString(dateVal) ? Date.parse(dateVal) : isDate(dateVal) ? dateVal.getTime() : isReference(dateVal) && isNumber(dateVal?.epoch?.ms) ? dateVal.epoch.ms : Date.now();
+  if (!Number.isFinite(epochMs))
+    return NaN;
+  const offsetMinutes = isText(tz) ? resolveCivilTimezoneOffset(tz, epochMs) : void 0;
+  const refMeridian = offsetMinutes !== void 0 ? offsetMinutes / 60 * 15 : Math.round(lng / 15) * 15;
+  const deltaLng = lng - refMeridian;
+  let offsetMin = deltaLng * 4;
+  if (options?.apparent) {
+    const d = new Date(epochMs);
+    const startOfYear = Date.UTC(d.getUTCFullYear(), 0, 1);
+    const dayOfYear = Math.floor((epochMs - startOfYear) / 864e5) + 1;
+    const gamma = 2 * Math.PI / 365 * (dayOfYear - 1);
+    const eqTime = 229.18 * (75e-6 + 1868e-6 * Math.cos(gamma) - 0.032077 * Math.sin(gamma) - 0.014615 * Math.cos(2 * gamma) - 0.040849 * Math.sin(2 * gamma));
+    offsetMin += eqTime;
+  }
+  const unit = options?.unit ?? "minutes";
+  let res;
+  if (unit === "seconds") {
+    res = offsetMin * 60;
+  } else if (unit === "hours") {
+    res = offsetMin / 60;
+  } else {
+    res = offsetMin;
+  }
+  const precision = options?.precision ?? 2;
+  const factor = Math.pow(10, precision);
+  return Math.round(res * factor) / factor;
+}
 
 // src/index.ts
 init_mapper_library2();
 init_mapper_library();
+init_assertion_library();
 var GeoPlugin = definePlugin({
   name: "geo",
-  install(TempoClass) {
-    TempoClass.geoLookup = geoLookup;
-    TempoClass.resolveGeoCoordinates = resolveGeoCoordinates;
-    TempoClass.serverGeoLocation = serverGeoLocation;
-    TempoClass.geoLocation = geoLocation;
+  install(TempoClass, options) {
+    const installedClass = TempoClass || this;
+    const getEffectiveOptions = (callSiteOpts, instance) => {
+      const classOpts = installedClass.config?.pluginOptions?.geo;
+      const instanceOpts = instance?.config?.pluginOptions?.geo;
+      return {
+        ...isObject(options) ? options : {},
+        ...isObject(classOpts) ? classOpts : {},
+        ...isObject(instanceOpts) ? instanceOpts : {},
+        ...isObject(callSiteOpts) ? callSiteOpts : {}
+      };
+    };
+    if (!Object.hasOwn(installedClass, "geo")) {
+      const geoNamespace = {
+        lookup: (opts) => geoLookup(getEffectiveOptions(opts)),
+        resolve: (target, opts) => resolveGeoCoordinates(target, getEffectiveOptions(opts, target)),
+        coerce: coerceGeo,
+        distance: haversineDistance,
+        solarOffset,
+        stash: stashGeo,
+        clear: clearStashedGeo,
+        get: getStashedGeo,
+        server: serverGeoLocation,
+        browser: geoLocation,
+        get current() {
+          return getStashedGeo() ?? installedClass.config?.geo;
+        }
+      };
+      Object.defineProperty(installedClass, "geo", {
+        value: (0, sdk_exports.deepFreeze)(geoNamespace),
+        writable: false,
+        configurable: false,
+        enumerable: false
+      });
+    }
     TempoClass.prototype.geoLocate = async function(opts) {
-      const coords = await resolveGeoCoordinates(this, opts);
+      const effectiveOpts = getEffectiveOptions(opts, this);
+      const setTimezone = effectiveOpts?.setTimezone !== false;
+      const coords = await resolveGeoCoordinates(this, effectiveOpts);
       if (coords) {
-        const existingGeo = typeof this.config.geo === "object" && this.config.geo !== null ? this.config.geo : {};
-        return new TempoClass(this, {
-          ...this.config,
-          geo: {
-            ...existingGeo,
-            latitude: coords.lat,
-            longitude: coords.lng
+        const existingGeo = isObject(this.config.geo) ? this.config.geo : {};
+        const customKeys = {};
+        for (const key of Object.keys(existingGeo)) {
+          if (isSafeKey(key) && !GEO_PROPERTIES.includes(key))
+            customKeys[key] = existingGeo[key];
+        }
+        const callSiteGeo = coerceGeo(opts) ?? {};
+        if (isObject(opts)) {
+          for (const key of Object.keys(opts)) {
+            if (isSafeKey(key) && !["setTimezone", "refresh", "ttl", "endpoint", "timeout", "catch", "debug", "geo"].includes(key)) {
+              if (!GEO_PROPERTIES.includes(key))
+                customKeys[key] = opts[key];
+            }
           }
+        }
+        const preservedElevation = isNumber(coords?.elevation) ? coords.elevation : isNumber(existingGeo.elevation) ? existingGeo.elevation : void 0;
+        const mergedGeo = {
+          ...customKeys,
+          ...coords,
+          ...isNumber(preservedElevation) ? { elevation: preservedElevation } : {},
+          ...callSiteGeo
+        };
+        if (isNumber(mergedGeo.latitude)) mergedGeo.latitude = Math.round(mergedGeo.latitude * 1e3) / 1e3;
+        if (isNumber(mergedGeo.longitude)) mergedGeo.longitude = Math.round(mergedGeo.longitude * 1e3) / 1e3;
+        if (!mergedGeo.sphere && isNumber(mergedGeo.latitude)) {
+          mergedGeo.sphere = mergedGeo.latitude > 1e-3 ? "north" : mergedGeo.latitude < -1e-3 ? "south" : "equator";
+        }
+        let instance = this;
+        const targetTz = mergedGeo.timezone;
+        if (setTimezone && isString(targetTz) && !isEmpty(targetTz))
+          instance = this.set({ timeZone: targetTz });
+        return new TempoClass(instance, {
+          ...instance.config,
+          geo: (0, sdk_exports.deepFreeze)(mergedGeo),
+          ...mergedGeo.sphere ? { sphere: mergedGeo.sphere } : {}
         });
       }
       return this;
     };
     TempoClass.prototype.geoLookup = async function(opts) {
-      return resolveGeoCoordinates(this, opts);
+      return resolveGeoCoordinates(this, getEffectiveOptions(opts, this));
+    };
+    TempoClass.prototype.geoDistance = function(other, unit) {
+      return haversineDistance(this, other, unit);
+    };
+    TempoClass.prototype.geoSolarOffset = function(options2) {
+      return solarOffset(this, options2);
     };
   }
 });
 var geoPlugin = GeoPlugin;
 var index_default = GeoPlugin;
 export {
+  GEO_PROPERTIES,
   GeoPlugin,
+  clearStashedGeo,
   coerceGeo,
   index_default as default,
   geoLocation,
   geoLookup,
   geoPlugin,
   getStashedGeo,
+  haversineDistance,
   resolveGeoCoordinates,
   serverGeoCoords,
   serverGeoLocation,
-  serverMapHemisphere
+  serverMapHemisphere,
+  solarOffset,
+  stashGeo
 };