@magmacomputing/tempo-plugin-geo 0.1.0 → 1.0.0

package/dist/index.js

@@ -257,7 +257,7 @@ 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;
+var isType, isPrimitive, isReference, isString, isText, isNumber, isInteger, isArray, isObject, isDate, isSymbol, isSymbolFor, isSafeKey, isNullish, isUndefined, isDefined, isFunction, isMap, isSet, isError, isEmpty;
 var init_assertion_library = __esm({
   "../../library/dist/common/primitives/assertion.library.js"() {
     "use strict";
@@ -267,6 +267,7 @@ var init_assertion_library = __esm({
     isPrimitive = (obj) => isType(obj, "String", "Number", "BigInt", "Boolean", "Symbol", "Undefined", "Void", "Null", "Empty");
     isReference = (obj) => !isPrimitive(obj);
     isString = (obj) => isType(obj, "String");
+    isText = (obj) => isString(obj) && obj.trim().length > 0;
     isNumber = (obj) => Number.isFinite(obj);
     isInteger = (obj) => isType(obj, "BigInt");
     isArray = (obj) => isType(obj, "Array");
@@ -340,37 +341,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));
@@ -852,8 +822,590 @@ var init_serialize_library = __esm({
       "%7C": "|",
       "%7D": "}"
     };
-    RE_SAFE_URI_CODES = new RegExp(Object.keys(SAFE_URI_MAP).join("|"), "gi");
-    symKey = /^@(@)?\(([^\)]*)\)$/;
+    RE_SAFE_URI_CODES = new RegExp(Object.keys(SAFE_URI_MAP).join("|"), "gi");
+    symKey = /^@(@)?\(([^\)]*)\)$/;
+  }
+});
+
+// ../../../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 (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();
+  }
+});
+
+// ../../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 (typeof k === "string")
+              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 && 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();
+    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;
+      }
+    };
+  }
+});
+
+// ../../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();
   }
 });
 
@@ -993,113 +1545,6 @@ var init_international_library = __esm({
   }
 });
 
-// ../../../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 (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();
-  }
-});
-
 // ../../library/dist/common/runtime/enumerate.library.js
 function value(val) {
   return { enumerable: false, configurable: false, writable: false, value: val };
@@ -1329,54 +1774,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 +2019,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 = () => {
@@ -1685,7 +2082,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 +2326,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 +2334,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 +2351,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,124 +2428,440 @@ __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.0.0" });
+var defineTerm = (config) => originalTerm({ ...config, version: "1.0.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;
+    const geoNamespace = {
+      lookup: geoLookup,
+      resolve: resolveGeoCoordinates,
+      coerce: coerceGeo,
+      distance: haversineDistance,
+      solarOffset,
+      stash: stashGeo,
+      clear: clearStashedGeo,
+      get: getStashedGeo,
+      server: serverGeoLocation,
+      browser: geoLocation,
+      get current() {
+        return getStashedGeo() ?? TempoClass.config?.geo;
+      }
+    };
+    Object.defineProperty(TempoClass, "geo", {
+      value: (0, sdk_exports.deepFreeze)(geoNamespace),
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
     TempoClass.prototype.geoLocate = async function(opts) {
+      const setTimezone = opts?.setTimezone !== false;
       const coords = await resolveGeoCoordinates(this, opts);
       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 customKeys = {};
+        for (const key of Object.keys(existingGeo)) {
+          if (isSafeKey(key) && !GEO_PROPERTIES.includes(key))
+            customKeys[key] = existingGeo[key];
+        }
+        const callSiteGeo = coerceGeo(opts) ?? {};
+        if (opts && typeof opts === "object") {
+          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;
@@ -2144,20 +2869,31 @@ var GeoPlugin = definePlugin({
     TempoClass.prototype.geoLookup = async function(opts) {
       return resolveGeoCoordinates(this, opts);
     };
+    TempoClass.prototype.geoDistance = function(other, unit) {
+      return haversineDistance(this, other, unit);
+    };
+    TempoClass.prototype.geoSolarOffset = function(options) {
+      return solarOffset(this, options);
+    };
   }
 });
 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
 };