@magmacomputing/tempo-plugin-geo 1.0.0 → 1.2.0

package/dist/install.js

@@ -0,0 +1,3262 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// ../../library/dist/common/primitives/symbol.library.js
+var $Target, $Discover, $Extensible, $Inspect, $LogConfig, $Registry, $Register, $SerializerRegistry, $Mutable, $Identity, $Unwrapped, sym;
+var init_symbol_library = __esm({
+  "../../library/dist/common/primitives/symbol.library.js"() {
+    "use strict";
+    $Target = /* @__PURE__ */ Symbol.for("$LibraryTarget");
+    $Discover = /* @__PURE__ */ Symbol.for("$LibraryDiscover");
+    $Extensible = /* @__PURE__ */ Symbol.for("$LibraryExtensible");
+    $Inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+    $LogConfig = /* @__PURE__ */ Symbol.for("$LibraryLogConfig");
+    $Registry = /* @__PURE__ */ Symbol.for("$LibraryRegistry");
+    $Register = /* @__PURE__ */ Symbol.for("$LibraryRegister");
+    $SerializerRegistry = /* @__PURE__ */ Symbol.for("$LibrarySerializerRegistry");
+    $Mutable = /* @__PURE__ */ Symbol.for("$LibraryMutable");
+    $Identity = /* @__PURE__ */ Symbol.for("$LibraryIdentity");
+    $Unwrapped = /* @__PURE__ */ Symbol.for("$LibraryUnwrapped");
+    sym = {
+      $Target,
+      $Discover,
+      $Extensible,
+      $Inspect,
+      $LogConfig,
+      $Registry,
+      $Register,
+      $SerializerRegistry,
+      $Identity,
+      $Mutable,
+      $Unwrapped
+    };
+  }
+});
+
+// ../../library/dist/common/primitives/primitive.library.js
+function unwrap(obj) {
+  let curr = obj;
+  let depth = 0;
+  const maxDepth = 50;
+  while (curr) {
+    const next = curr[sym.$Target];
+    if (!next || depth >= maxDepth)
+      break;
+    curr = next;
+    depth++;
+  }
+  return curr;
+}
+function ownEntries(json, all = false) {
+  if (!json || typeof json !== "object")
+    return [];
+  const tgt = unwrap(json);
+  if (!all) {
+    const keys = Reflect.ownKeys(tgt);
+    const entries2 = [];
+    for (const k of keys) {
+      const desc = Object.getOwnPropertyDescriptor(tgt, k);
+      if (desc && desc.enumerable)
+        entries2.push([k, tgt[k]]);
+    }
+    return entries2;
+  }
+  const levels = [];
+  const limit = 50;
+  let depth = 0;
+  let curr = tgt;
+  while (curr && curr !== Object.prototype && depth++ < limit) {
+    levels.push(unwrap(curr));
+    curr = Object.getPrototypeOf(curr);
+  }
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const level of levels.reverse()) {
+    const keys = Reflect.ownKeys(level);
+    for (const k of keys) {
+      if (seen.has(k))
+        continue;
+      const desc = Object.getOwnPropertyDescriptor(level, k);
+      if (!desc || !desc.enumerable)
+        continue;
+      seen.add(k);
+      entries.push([k, tgt[k]]);
+    }
+  }
+  return entries;
+}
+function ownKeys(json, all = false) {
+  return ownEntries(json, all).map(([key]) => key);
+}
+function ownValues(json, all = false) {
+  return ownEntries(json, all).map(([_, value2]) => value2);
+}
+function distinct(arr, mapfn, thisArg) {
+  return mapfn ? distinct(arr.map(mapfn, thisArg)) : Array.from(new Set(arr));
+}
+var init_primitive_library = __esm({
+  "../../library/dist/common/primitives/primitive.library.js"() {
+    "use strict";
+    init_symbol_library();
+  }
+});
+
+// ../../library/dist/common/primitives/type.library.js
+var registry, protoType, getSafeTag, getType, asType, classRegex, isClassConstructor, registerType;
+var init_type_library = __esm({
+  "../../library/dist/common/primitives/type.library.js"() {
+    "use strict";
+    init_symbol_library();
+    init_primitive_library();
+    registry = [];
+    protoType = (obj) => {
+      if (obj === null)
+        return "Null";
+      if (obj === void 0)
+        return "Undefined";
+      const t = typeof obj;
+      if (t === "string")
+        return "String";
+      if (t === "number")
+        return "Number";
+      if (t === "boolean")
+        return "Boolean";
+      if (t === "bigint")
+        return "BigInt";
+      if (t === "symbol")
+        return "Symbol";
+      try {
+        const raw = t === "object" ? unwrap(obj) : obj;
+        return Object.prototype.toString.call(raw).slice(8, -1);
+      } catch {
+        return t === "function" ? "Function" : "Object";
+      }
+    };
+    getSafeTag = (obj) => {
+      try {
+        const tag2 = obj?.[Symbol.toStringTag] ?? obj?.prototype?.[Symbol.toStringTag];
+        if (typeof tag2 === "string")
+          return tag2;
+      } catch {
+      }
+      return void 0;
+    };
+    getType = (obj, ...instances) => {
+      let raw = obj;
+      try {
+        raw = obj?.[sym.$Target] ?? obj;
+      } catch {
+        raw = obj;
+      }
+      const type = protoType(raw);
+      switch (type) {
+        case "Function":
+          try {
+            return isClassConstructor(raw) ? "Class" : "Function";
+          } catch {
+            return "Function";
+          }
+        case "Object": {
+          try {
+            if ("length" in raw && Object.keys(raw).every((key) => key === "length" || Number.isFinite(Number(key))))
+              return "ArrayLike";
+            for (const inst of instances) {
+              const instRaw = inst.class?.[sym.$Target] ?? inst.class;
+              if (raw === instRaw || instRaw && raw instanceof instRaw)
+                return inst.type;
+            }
+            const globalRegistry = globalThis[sym.$Registry] ?? [];
+            for (const inst of [...registry, ...globalRegistry]) {
+              const instRaw = inst.class?.[sym.$Target] ?? inst.class;
+              if (raw === instRaw || instRaw && raw instanceof instRaw)
+                return inst.type;
+            }
+          } catch {
+            return "Object";
+          }
+          return "Object";
+        }
+        default:
+          return type;
+      }
+    };
+    asType = (value2, ...instances) => ({ type: getType(value2, ...instances), value: value2 });
+    classRegex = /^\s*(class\s|\[native code\])/;
+    isClassConstructor = (obj) => {
+      if (typeof obj !== "function")
+        return false;
+      const raw = obj?.[sym.$Target] ?? obj;
+      if (!("prototype" in raw))
+        return false;
+      const name = raw?.name;
+      const tag2 = getSafeTag(raw);
+      if (raw?.[sym.$Identity] || raw?.prototype?.[sym.$Identity]) {
+        return true;
+      }
+      if (typeof tag2 === "string" && tag2.startsWith("Temporal.")) {
+        return true;
+      }
+      if (typeof tag2 === "string" && tag2.endsWith("Function"))
+        return false;
+      const globalRegistry = globalThis[sym.$Registry] ?? [];
+      if (globalRegistry.some((inst) => (inst.class?.[sym.$Target] ?? inst.class) === raw || name && inst.type === name || tag2 && inst.type === tag2)) {
+        return true;
+      }
+      try {
+        const str = Function.prototype.toString.call(raw);
+        if (classRegex.test(str)) {
+          return true;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(raw, "prototype");
+        if (descriptor && descriptor.writable === false && !Object.isFrozen(raw)) {
+          return true;
+        }
+        const proto = raw.prototype;
+        if (proto && Object.getOwnPropertyNames(proto).length > 2) {
+          return true;
+        }
+      } catch {
+        return false;
+      }
+      return false;
+    };
+    registerType = (cls, type) => {
+      if (typeof cls !== "function")
+        return;
+      const tag2 = getSafeTag(cls);
+      const name = type ?? tag2 ?? cls.name;
+      if (name && !["Object", "Function", ""].includes(name)) {
+        if (!registry.some((inst) => inst.class === cls))
+          registry.push({ class: cls, type: name });
+      }
+    };
+  }
+});
+
+// ../../library/dist/common/primitives/assertion.library.js
+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) => obj === null || typeof obj !== "object" && typeof obj !== "function";
+    isReference = (obj) => !isPrimitive(obj);
+    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);
+    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");
+    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) => 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());
+  }
+});
+
+// ../../library/dist/common/runtime/utility.library.js
+function deepFreeze(obj, options, seen = /* @__PURE__ */ new WeakSet()) {
+  const skip = options instanceof WeakSet ? options : options?.skip ?? EMPTY_SKIP;
+  if (isPrimitive(obj) || seen.has(obj) || skip.has(obj))
+    return obj;
+  if (obj instanceof Date || obj instanceof RegExp || obj instanceof Error || obj instanceof Map || obj instanceof Set || obj instanceof Promise)
+    return obj;
+  if (obj?.[Symbol.toStringTag] === "Enumify")
+    return obj;
+  if (obj[sym.$Extensible])
+    return obj;
+  seen.add(obj);
+  ownEntries(obj).forEach(([key, val]) => {
+    if (isSafeKey(key))
+      deepFreeze(val, { skip }, seen);
+  });
+  return Object.freeze(obj);
+}
+var CONTEXT, getContext, EMPTY_SKIP;
+var init_utility_library = __esm({
+  "../../library/dist/common/runtime/utility.library.js"() {
+    "use strict";
+    init_primitive_library();
+    init_assertion_library();
+    init_symbol_library();
+    CONTEXT = {
+      "Unknown": "unknown",
+      "Browser": "browser",
+      "WebWorker": "web-worker",
+      "NodeJS": "nodejs",
+      "Deno": "deno",
+      "GoogleAppsScript": "google-apps-script"
+    };
+    getContext = () => {
+      const global = globalThis;
+      try {
+        if (isDefined(global.SpreadsheetApp))
+          return { global, type: CONTEXT.GoogleAppsScript };
+        if (isDefined(global.window?.document))
+          return { global, type: CONTEXT.Browser };
+        if (isFunction(global.importScripts) || isDefined(global.WorkerGlobalScope) && global instanceof global.WorkerGlobalScope)
+          return { global, type: CONTEXT.WebWorker };
+        if (isDefined(global.Deno))
+          return { global, type: CONTEXT.Deno };
+        if (isDefined(global.process?.versions?.node) && global.process?.release?.name === "node")
+          return { global, type: CONTEXT.NodeJS };
+      } catch {
+      }
+      return { global, type: CONTEXT.Unknown };
+    };
+    EMPTY_SKIP = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// ../../library/dist/common/runtime/reflection.library.js
+function allObject(json) {
+  return Object.fromEntries(ownEntries(json, true));
+}
+var init_reflection_library = __esm({
+  "../../library/dist/common/runtime/reflection.library.js"() {
+    "use strict";
+    init_primitive_library();
+    init_type_library();
+    init_assertion_library();
+  }
+});
+
+// ../../library/dist/common/runtime/proxy.library.js
+function factory(target, options = {}, isRevocable = false) {
+  const { frozen, lock, appendOnly, onGet, keys, bind, skip } = options;
+  const pending = /* @__PURE__ */ new Set();
+  let cachedJSON;
+  let result;
+  const tgt = unwrap(target);
+  if (lock)
+    deepFreeze(tgt, skip ? { skip } : void 0);
+  registerType(tgt);
+  const handler = {
+    isExtensible: (t) => Reflect.isExtensible(t),
+    getPrototypeOf: (t) => Reflect.getPrototypeOf(t),
+    setPrototypeOf: (t, proto) => {
+      if (frozen)
+        throw new TypeError("Security: Prototype mutation attempt on protected object");
+      return Reflect.setPrototypeOf(t, proto);
+    },
+    getOwnPropertyDescriptor: (t, k) => {
+      if (keys && !keys.includes(k))
+        return void 0;
+      if (keys) {
+        if (onGet && !isSymbol(k) && !pending.has(k)) {
+          pending.add(k);
+          try {
+            const value2 = onGet(k, t);
+            if (isDefined(value2))
+              return { enumerable: true, configurable: true, value: value2 };
+          } finally {
+            pending.delete(k);
+          }
+        }
+        return { enumerable: true, configurable: true };
+      }
+      return Reflect.getOwnPropertyDescriptor(t, k);
+    },
+    ownKeys: (t) => {
+      if (keys)
+        return keys;
+      if (onGet && !pending.has(sym.$Discover)) {
+        pending.add(sym.$Discover);
+        try {
+          onGet(sym.$Discover, t);
+        } finally {
+          pending.delete(sym.$Discover);
+        }
+      }
+      return Reflect.ownKeys(t);
+    },
+    has: (t, k) => keys ? keys.includes(k) : Reflect.has(t, k),
+    deleteProperty: (t, k) => {
+      if (frozen)
+        throw new TypeError(`Cannot delete property '${String(k)}' from a protected object.`);
+      if (appendOnly && Reflect.has(t, k))
+        throw new Error(`Security: Deletion attempt on protected key '${String(k)}'`);
+      return Reflect.deleteProperty(t, k);
+    },
+    defineProperty: (t, k, d) => {
+      if (frozen && !Object.isFrozen(t))
+        throw new TypeError(`Cannot define property '${String(k)}' on a frozen object.`);
+      if (appendOnly && Reflect.has(t, k))
+        throw new Error(`Security: Mutation attempt on protected key '${String(k)}'`);
+      return Reflect.defineProperty(t, k, d);
+    },
+    set: (t, k, v, r) => {
+      if (frozen && r === result)
+        throw new TypeError(`Cannot set property '${String(k)}' on a frozen object.`);
+      if (appendOnly) {
+        const isTruncating = Array.isArray(t) && k === "length" && v < t.length;
+        if (isTruncating)
+          throw new Error("Security: Truncation attempt on protected array.");
+        if (!(Array.isArray(t) && k === "length") && Reflect.has(t, k))
+          throw new Error(`Security: Mutation attempt on protected key '${String(k)}'`);
+      }
+      return Reflect.set(t, k, v, r);
+    },
+    get: (t, k, r) => {
+      if (k === sym.$Target)
+        return r === result ? t : void 0;
+      if (frozen && (k === sym.$Inspect || k === "toJSON")) {
+        const own = Object.getOwnPropertyDescriptor(t, k);
+        if (own && isFunction(own.value))
+          return own.value;
+        if (!cachedJSON)
+          cachedJSON = () => allObject(t);
+        return cachedJSON;
+      }
+      if (keys && !keys.includes(k))
+        return void 0;
+      if (onGet && !isSymbol(k) && !Reflect.has(t, k) && !pending.has(k)) {
+        pending.add(k);
+        try {
+          const val2 = onGet(k, t);
+          if (isDefined(val2))
+            return val2;
+        } finally {
+          pending.delete(k);
+        }
+      }
+      const val = Reflect.get(t, k, r);
+      if (bind && k !== "constructor" && isFunction(val)) {
+        const desc = Object.getOwnPropertyDescriptor(t, k);
+        if (desc && !desc.configurable && !desc.writable)
+          return val;
+        let perTargetCache = boundMethodCache.get(val);
+        if (!perTargetCache) {
+          perTargetCache = /* @__PURE__ */ new WeakMap();
+          boundMethodCache.set(val, perTargetCache);
+        }
+        const cachedBound = perTargetCache.get(t);
+        if (cachedBound)
+          return cachedBound;
+        const bound = val.bind(t);
+        perTargetCache.set(t, bound);
+        return bound;
+      }
+      return val;
+    }
+  };
+  if (isRevocable) {
+    const revocableResult = Proxy.revocable(tgt, handler);
+    result = revocableResult.proxy;
+    return { proxy: revocableResult.proxy, revoke: revocableResult.revoke };
+  }
+  result = new Proxy(tgt, handler);
+  return result;
+}
+function proxify(target, frozen = true, lock = frozen, skip = /* @__PURE__ */ new WeakSet()) {
+  return factory(target, { frozen, lock, skip, bind: frozen });
+}
+function secure(obj, skip = /* @__PURE__ */ new WeakSet()) {
+  return factory(obj, { frozen: true, lock: true, skip, bind: true });
+}
+var boundMethodCache;
+var init_proxy_library = __esm({
+  "../../library/dist/common/runtime/proxy.library.js"() {
+    "use strict";
+    init_symbol_library();
+    init_reflection_library();
+    init_utility_library();
+    init_primitive_library();
+    init_assertion_library();
+    init_type_library();
+    boundMethodCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// ../../library/dist/common/runtime/function.library.js
+function serialize(val, seen = /* @__PURE__ */ new WeakSet()) {
+  return JSON.stringify(val, function(key, value2) {
+    if (value2 === void 0)
+      return "\0__undefined__\0";
+    if (isInteger(value2))
+      return `\0__bigint:${value2}__\0`;
+    if (isFunction(value2))
+      return `function:${value2.name || "anonymous"}`;
+    if (isReference(value2)) {
+      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))
+        return `set:[${Array.from(value2).map((v) => serialize(v, seen)).sort().join(",")}]`;
+    }
+    return value2;
+  });
+}
+function curry(fn) {
+  return function curried(...args) {
+    return args.length >= fn.length ? fn(...args) : (...nextArgs) => curried(...args, ...nextArgs);
+  };
+}
+function memoizeFunction(fn) {
+  const cache = /* @__PURE__ */ new Map();
+  return function(...args) {
+    const key = this !== void 0 && this !== globalThis ? serialize([this, ...args]) : serialize(args);
+    if (!cache.has(key)) {
+      const result = fn.apply(this, args);
+      cache.set(key, result);
+    }
+    return cache.get(key);
+  };
+}
+function memoizeMethod(name, fn) {
+  return {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: function(...args) {
+      const key = `${String(name)},${serialize(args)}`;
+      let cache = wm.get(this);
+      if (!cache) {
+        cache = /* @__PURE__ */ new Map();
+        wm.set(this, cache);
+      }
+      if (!cache.has(key)) {
+        const result = fn.apply(this, args);
+        secure(result);
+        cache.set(key, result);
+      }
+      return cache.get(key);
+    }
+  };
+}
+var wm;
+var init_function_library = __esm({
+  "../../library/dist/common/runtime/function.library.js"() {
+    "use strict";
+    init_proxy_library();
+    init_assertion_library();
+    wm = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// ../../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 clone(obj, opts) {
+  try {
+    return globalThis.structuredClone(obj, opts);
+  } catch {
+    return cleanify(obj);
+  }
+}
+function reviver(_key, val) {
+  return decode(val);
+}
+function encode(val) {
+  let enc = encodeURI(val);
+  if (enc.includes("%"))
+    enc = enc.replace(RE_SAFE_URI_CODES, (match) => SAFE_URI_MAP[match.toUpperCase()] ?? decodeURI(match));
+  return enc;
+}
+function decode(val) {
+  if (isString(val)) {
+    try {
+      return decodeURI(val);
+    } catch (error) {
+    }
+  }
+  return val;
+}
+function isStringable(val) {
+  return !isType(val, "Function", "AsyncFunction", "WeakMap", "WeakSet", "WeakRef");
+}
+function oneKey(type, value2) {
+  return `{"$${type}":${value2}}`;
+}
+function fromSymbol(key) {
+  return stringize(isSymbol(key) ? `${isSymbolFor(key) ? "@" : ""}@(${key.description ?? ""})` : key);
+}
+function toSymbol(value2) {
+  const [pat, keyFor, desc] = value2.toString().match(symKey) || [null, void 0, void 0];
+  switch (true) {
+    case isSymbol(value2):
+    // already a Symbol
+    case isNullish(pat):
+    // incorrectly encoded Symbol
+    case (isDefined(keyFor) && isUndefined(desc)):
+      return value2;
+    case isDefined(keyFor):
+      return Symbol.for(desc);
+    case isUndefined(keyFor):
+    // local Symbol
+    default:
+      return Symbol(desc);
+  }
+}
+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": {
+      let strVal = arg.value;
+      if (strVal.startsWith("~"))
+        strVal = `~${strVal}`;
+      if (!recurse) {
+        recurse = strVal === "true" || strVal === "false" || strVal === "null" || parseFloat(strVal).toString() === strVal || strVal.startsWith("~");
+      }
+      return recurse ? JSON.stringify(encode(strVal)) : encode(strVal);
+    }
+    case "Boolean":
+    case "Null":
+    case "Number":
+      return JSON.stringify(arg.value);
+    // JSON.stringify will correctly handle these
+    case "Void":
+    case "Undefined":
+      return activeCompact ? JSON.stringify("~u") : one(JSON.stringify("void"));
+    // preserve 'undefined' values		
+    case "BigInt":
+      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}}`;
+    }
+    case "Array": {
+      const arr = arg.value.filter((val) => isStringable(val)).map((val) => stringize(val)).join(",");
+      return `[${arr}]`;
+    }
+    case "Map": {
+      const map = Array.from(arg.value.entries()).filter(([, val]) => isStringable(val)).map(([key, val]) => `[${stringize(key)}, ${stringize(val)}]`).join(",");
+      return one(`[${map}]`);
+    }
+    case "Set": {
+      const set = Array.from(arg.value.values()).filter((val) => isStringable(val)).map((val) => stringize(val)).join(",");
+      return one(`[${set}]`);
+    }
+    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":
+    default: {
+      const value2 = arg.value;
+      switch (true) {
+        case !isStringable(value2):
+          return void 0;
+        case isFunction(value2.toJSON):
+          return one(stringize(value2.toJSON()));
+        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) && value2.valueOf !== Object.prototype.valueOf):
+          return one(JSON.stringify(value2.valueOf()));
+        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, 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);
+  } catch (error) {
+    if (str.startsWith('"') && str.endsWith('"')) {
+      console.warn(`objectify.parse: -> ${str}, ${error.message}`);
+      return str;
+    } else
+      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, options, 0);
+    // recurse into object
+    default:
+      return typeify(parse, options);
+  }
+}
+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).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, options, depth + 1), options));
+  }
+  return typeify(obj, options);
+}
+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];
+  if (!String($type).startsWith("$"))
+    return json;
+  const type = $type.substring(1);
+  try {
+    switch (type) {
+      case "String":
+      case "Boolean":
+      case "Object":
+      case "Array":
+        return value2;
+      // these types are already handled by traverse()
+      case "Number":
+        return Number(value2);
+      case "BigInt":
+        return BigInt(value2);
+      case "Null":
+        return null;
+      case "Undefined":
+      case "Empty":
+      case "Void":
+        return options.sentinel?.();
+      // run Sentinel function to handle undefined values
+      case "Date":
+        return new Date(value2);
+      case "RegExp":
+        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":
+        return toSymbol(value2);
+      case "Map":
+        if (!isArray(value2))
+          return json;
+        return new Map(value2);
+      case "Set":
+        if (!isArray(value2))
+          return json;
+        return new Set(value2);
+      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, 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();
+    Registry = globalThis[sym.$SerializerRegistry] ??= /* @__PURE__ */ new Map();
+    getSafeTag2 = (c) => {
+      try {
+        const tag2 = c?.prototype?.[Symbol.toStringTag] ?? c?.[Symbol.toStringTag];
+        return isString(tag2) ? tag2 : void 0;
+      } catch {
+        return void 0;
+      }
+    };
+    registerSerializable = (name, cls) => {
+      const key = name.startsWith("$") ? name : `$${name}`;
+      if (Registry.has(key)) {
+        const existingCls = Registry.get(key);
+        const existingTag = getSafeTag2(existingCls);
+        const clsTag = getSafeTag2(cls);
+        const existingName = existingCls.name || existingTag;
+        const currentName = cls.name || clsTag || (name.startsWith("$") ? name.slice(1) : name);
+        const isSameConstructor = existingCls === cls || existingCls.toString() === cls.toString() || Boolean(cls[sym.$Identity]) && existingCls[sym.$Identity] === cls[sym.$Identity] || Boolean(cls[sym.$Target]) && existingCls[sym.$Target] === cls[sym.$Target] || Boolean(existingName) && Boolean(currentName) && existingName === currentName;
+        if (isSameConstructor)
+          return;
+        throw new Error(`[registerSerializable] Collision: '${key}' is already registered with ${existingCls.name || "anonymous constructor"}`);
+      }
+      Registry.set(key, cls);
+    };
+    SAFE_URI_MAP = {
+      "%20": " ",
+      "%22": '"',
+      "%3B": ";",
+      "%3C": "<",
+      "%3E": ">",
+      "%5B": "[",
+      "%5D": "]",
+      "%5E": "^",
+      "%7B": "{",
+      "%7C": "|",
+      "%7D": "}"
+    };
+    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;
+      }
+    };
+  }
+});
+
+// ../../library/dist/common/primitives/string.library.js
+var init_string_library = __esm({
+  "../../library/dist/common/primitives/string.library.js"() {
+    "use strict";
+    init_serialize_library();
+    init_assertion_library();
+  }
+});
+
+// ../../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;
+  const error = new Error(isObject(err) && isString(err.message) ? err.message : String(err));
+  if (isObject(err)) {
+    error.name = isString(err.name) ? err.name : "Error";
+    if ("code" in err && (isString(err.code) || isNumber(err.code)))
+      error.code = err.code;
+    if ("stack" in err && isString(err.stack))
+      error.stack = err.stack;
+  }
+  return error;
+}
+var MAX_SAFE_INTEGER_BIGINT, MIN_SAFE_INTEGER_BIGINT;
+var init_coercion_library = __esm({
+  "../../library/dist/common/primitives/coercion.library.js"() {
+    "use strict";
+    init_serialize_library();
+    init_type_library();
+    init_assertion_library();
+    init_string_library();
+    MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+    MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+  }
+});
+
+// ../../library/dist/common/temporal/temporal.polyfill.js
+var init_temporal_polyfill = __esm({
+  "../../library/dist/common/temporal/temporal.polyfill.js"() {
+    "use strict";
+    init_coercion_library();
+    if (typeof globalThis.Temporal === "undefined") {
+      throw new Error("Temporal API is not available. Node 20+ with a polyfill (e.g. @js-temporal/polyfill) is highly recommended. Native Temporal is fully reliable only on Node 26+ (while Node 22 may have instabilities).");
+    }
+    try {
+      if (typeof Temporal.Now.zonedDateTimeISO === "function") {
+        const zdt = Temporal.Now.zonedDateTimeISO();
+        if (typeof zdt.add !== "function")
+          throw new Error("Incomplete Temporal implementation");
+      }
+    } catch (err) {
+      const error = asError(err);
+      console.warn("Tempo: Native Temporal implementation appears incomplete. Consider loading a polyfill.", error);
+      if (error.message !== "Incomplete Temporal implementation")
+        throw error;
+    }
+  }
+});
+
+// ../../library/dist/common/temporal/temporal.library.js
+function instant() {
+  return Temporal.Now.instant();
+}
+function getOffsets(timeZone, year = 2024) {
+  const jan = Temporal.ZonedDateTime.from({ year, month: 1, day: 1, hour: 0, minute: 0, second: 0, timeZone }).offsetNanoseconds;
+  const jul = Temporal.ZonedDateTime.from({ year, month: 7, day: 1, hour: 0, minute: 0, second: 0, timeZone }).offsetNanoseconds;
+  return { jan, jul };
+}
+var init_temporal_library = __esm({
+  "../../library/dist/common/temporal/temporal.library.js"() {
+    "use strict";
+    init_temporal_polyfill();
+    init_assertion_library();
+  }
+});
+
+// ../../library/dist/common/runtime/international.library.js
+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;
+}
+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();
+    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, options) => {
+      return new Intl.ListFormat(cleanLocaleTag(locale), options);
+    });
+    getDTF = memoizeFunction((locale, options) => {
+      return new Intl.DateTimeFormat(cleanLocaleTag(locale), options);
+    });
+    getPR = memoizeFunction((locale, options) => {
+      try {
+        return new Intl.PluralRules(cleanLocaleTag(locale), options);
+      } catch (e) {
+        return { select: () => "other" };
+      }
+    });
+    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));
+    });
+    getHemisphere = memoizeFunction((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) {
+        return void 0;
+      }
+    });
+    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;
+      }
+    });
+  }
+});
+
+// ../../library/dist/common/runtime/enumerate.library.js
+function value(val) {
+  return { enumerable: false, configurable: false, writable: false, value: val };
+}
+function enumify(list, frozen = true) {
+  const type = getType(this);
+  const proto = type !== "Module" && isFunction(this?.has) ? this : ENUM;
+  const arg = asType(list);
+  const target = Object.create(proto);
+  switch (arg.type) {
+    case "Enumify":
+    case "Object":
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(arg.value));
+      break;
+    case "Array":
+      arg.value.forEach((key, index) => {
+        if (isNumber(key))
+          throw new Error("Enumify: numeric keys are not supported");
+        target[key] = index;
+      });
+      break;
+    default:
+      throw new Error(`Enumify: invalid argument type: ${arg.type}`);
+  }
+  return proxify(target, true, frozen);
+}
+var tag, ENUM, Enumify;
+var init_enumerate_library = __esm({
+  "../../library/dist/common/runtime/enumerate.library.js"() {
+    "use strict";
+    init_tslib_es6();
+    init_type_library();
+    init_assertion_library();
+    init_primitive_library();
+    init_proxy_library();
+    init_decorator_library();
+    init_function_library();
+    tag = "Enumify";
+    ENUM = secure(Object.create(null, {
+      keys: memoizeMethod("keys", function() {
+        return ownEntries(this, true).map(([key]) => key);
+      }),
+      values: memoizeMethod("values", function() {
+        return ownEntries(this, true).map(([_, val]) => val);
+      }),
+      entries: memoizeMethod("entries", function() {
+        return ownEntries(this, true).map(([key, val]) => Object.freeze([key, val]));
+      }),
+      invert: memoizeMethod("invert", function() {
+        return Object.fromEntries(this.entries().map(([key, val]) => [val, key]));
+      }),
+      has: value(function(key) {
+        return this.keys().includes(key);
+      }),
+      count: value(function() {
+        return this.keys().length;
+      }),
+      includes: value(function(search) {
+        return this.values().includes(search);
+      }),
+      keyOf: value(function(search) {
+        return this.invert()[search];
+      }),
+      extend: value(function(list, frozen) {
+        return enumify.call(this, list, frozen);
+      }),
+      forEach: value(function(fn, thisArg) {
+        this.entries().forEach((entry, index) => fn.call(thisArg, entry, index, this));
+      }),
+      filter: value(function(fn, thisArg) {
+        return enumify(this.entries().reduce((acc, entry, index) => fn.call(thisArg, entry, index, this) ? Object.assign(acc, { [entry[0]]: entry[1] }) : acc, {}));
+      }),
+      map: value(function(fn, thisArg) {
+        return enumify(this.entries().reduce((acc, entry, index) => Object.assign(acc, { [entry[0]]: fn.call(thisArg, entry, index, this) }), {}));
+      }),
+      [Symbol.iterator]: value(function* () {
+        for (const entry of this.entries())
+          yield entry;
+      }),
+      [Symbol.toStringTag]: { enumerable: false, configurable: false, writable: false, value: tag }
+    }));
+    Enumify = (() => {
+      let _classDecorators = [Serializable, StringTag("Enumify")];
+      let _classDescriptor;
+      let _classExtraInitializers = [];
+      let _classThis;
+      var Enumify2 = class {
+        static {
+          _classThis = this;
+        }
+        static {
+          const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
+          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+          Enumify2 = _classThis = _classDescriptor.value;
+          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+          __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor(list) {
+          return enumify(list);
+        }
+      };
+      return Enumify2 = _classThis;
+    })();
+  }
+});
+
+// ../../library/dist/common/runtime/logger.class.js
+function parseLogLevel(level, fallback = LOG.Info) {
+  if (isNumber(level))
+    return level >= LOG.Off && level <= LOG.Trace ? level : fallback;
+  if (isString(level))
+    return Level[level.toLowerCase()] ?? fallback;
+  return fallback;
+}
+var LOG, Method, Level, Logger;
+var init_logger_class = __esm({
+  "../../library/dist/common/runtime/logger.class.js"() {
+    "use strict";
+    init_tslib_es6();
+    init_assertion_library();
+    init_enumerate_library();
+    init_symbol_library();
+    init_decorator_library();
+    LOG = enumify(["Off", "Error", "Warn", "Info", "Debug", "Trace"]);
+    Method = {
+      Off: "off",
+      Log: "log",
+      Info: "info",
+      Warn: "warn",
+      Debug: "debug",
+      Trace: "trace",
+      Error: "error"
+    };
+    Level = {
+      [Method.Off]: LOG.Off,
+      [Method.Error]: LOG.Error,
+      [Method.Warn]: LOG.Warn,
+      [Method.Info]: LOG.Info,
+      [Method.Log]: LOG.Info,
+      [Method.Debug]: LOG.Debug,
+      [Method.Trace]: LOG.Trace
+    };
+    Logger = (() => {
+      let _classDecorators = [StringTag("Logger")];
+      let _classDescriptor;
+      let _classExtraInitializers = [];
+      let _classThis;
+      var Logger2 = class {
+        static {
+          _classThis = this;
+        }
+        static {
+          const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
+          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+          Logger2 = _classThis = _classDescriptor.value;
+          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+          __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #namespace;
+        /** The current verbosity level */
+        level;
+        constructor(namespace, level = LOG.Info) {
+          this.#namespace = namespace.startsWith("[") ? namespace : `[${namespace}]`;
+          this.level = level;
+        }
+        #emit(method, ...msg) {
+          let config;
+          if (msg.length > 0 && isObject(msg[0])) {
+            try {
+              if (msg[0][sym.$LogConfig]) {
+                config = msg.shift();
+              }
+            } catch {
+            }
+          }
+          let activeLevel = this.level;
+          if (config) {
+            if (config.silent === true)
+              return;
+            if (config.debug !== void 0) {
+              activeLevel = parseLogLevel(config.debug, activeLevel);
+            }
+          }
+          if (activeLevel === LOG.Off)
+            return;
+          const methodLevel = Level[method] ?? 0;
+          if (methodLevel > activeLevel)
+            return;
+          const output = msg.map((m) => {
+            if (isError(m))
+              return m.message;
+            if (isObject(m)) {
+              try {
+                const name = m.constructor?.name ?? "Object";
+                if (name === "Object") {
+                  const keys = Object.keys(m);
+                  const summary = keys.slice(0, 3).join(", ");
+                  return `{ ${summary}${keys.length > 3 ? `, ... (+${keys.length - 3} more)` : ""} }`;
+                }
+                return `[${name}]`;
+              } catch {
+                return "[Object]";
+              }
+            }
+            return String(m);
+          }).filter((s) => !isEmpty(s)).join(" ");
+          if (!isEmpty(output)) {
+            const consoleMethod = method;
+            console[consoleMethod](`${this.#namespace} ${output}`);
+          }
+        }
+        /** console.log */
+        log = (...msg) => this.#emit(Method.Log, ...msg);
+        /** console.info */
+        info = (...msg) => this.#emit(Method.Info, ...msg);
+        /** console.warn */
+        warn = (...msg) => this.#emit(Method.Warn, ...msg);
+        /** console.debug */
+        debug = (...msg) => this.#emit(Method.Debug, ...msg);
+        /** console.trace */
+        trace = (...msg) => this.#emit(Method.Trace, ...msg);
+        /** console.error */
+        error = (...msg) => this.#emit(Method.Error, ...msg);
+      };
+      return Logger2 = _classThis;
+    })();
+  }
+});
+
+// ../../library/dist/browser/webstore.class.js
+var webstore_class_exports = {};
+__export(webstore_class_exports, {
+  WebStore: () => WebStore
+});
+var STORAGE, WebStore;
+var init_webstore_class = __esm({
+  "../../library/dist/browser/webstore.class.js"() {
+    "use strict";
+    init_tslib_es6();
+    init_primitive_library();
+    init_serialize_library();
+    init_type_library();
+    init_assertion_library();
+    init_storage_library();
+    init_decorator_library();
+    STORAGE = {
+      Local: "local",
+      Session: "session"
+    };
+    WebStore = (() => {
+      let _classDecorators = [StringTag("WebStore")];
+      let _classDescriptor;
+      let _classExtraInitializers = [];
+      let _classThis;
+      var WebStore2 = class {
+        static {
+          _classThis = this;
+        }
+        static {
+          const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
+          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+          WebStore2 = _classThis = _classDescriptor.value;
+          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+          __runInitializers(_classThis, _classExtraInitializers);
+        }
+        static _localInstance;
+        static _sessionInstance;
+        /**
+         * Lazy getter for the localStorage wrapper instance.
+         *
+         * @returns The WebStore instance for localStorage
+         */
+        static get local() {
+          return WebStore2._localInstance ??= new WebStore2(STORAGE.Local);
+        }
+        /**
+         * Lazy getter for the sessionStorage wrapper instance.
+         *
+         * @returns The WebStore instance for sessionStorage
+         */
+        static get session() {
+          return WebStore2._sessionInstance ??= new WebStore2(STORAGE.Session);
+        }
+        #type;
+        #resolvedStorage;
+        /** Resolved Storage object (resolved safely on access with memory fallback) */
+        get #storage() {
+          if (this.#resolvedStorage)
+            return this.#resolvedStorage;
+          const name = this.#type === STORAGE.Local ? "localStorage" : "sessionStorage";
+          return this.#resolvedStorage = getSafeStorage(name);
+        }
+        #exec(op) {
+          try {
+            return op(this.#storage);
+          } catch (e) {
+            const name = this.#type === STORAGE.Local ? "localStorage" : "sessionStorage";
+            const fallback = getMemoryStorage(name);
+            this.#resolvedStorage = fallback;
+            return op(fallback);
+          }
+        }
+        constructor(storage2 = STORAGE.Local) {
+          this.#type = storage2;
+        }
+        /**
+         * Retrieve a value from storage, optionally providing a default.
+         *
+         * @param key - The property key to retrieve
+         * @param dflt - An optional default value if the key does not exist
+         * @returns The parsed object from storage, or the default/null if not found
+         */
+        get(key, dflt) {
+          const str = this.#exec((storage2) => storage2.getItem(stringify(key)));
+          return isString(str) ? objectify(str) : dflt ?? null;
+        }
+        /**
+         * Store or merge a value into storage for a given key.
+         *
+         * @param key - The property key to set. If nullish, clears the store.
+         * @param obj - The value to store
+         * @param opt - Options (merge behavior)
+         * @returns The WebStore instance for chaining
+         */
+        set(key, obj, opt = { merge: true }) {
+          if (isNullish(key))
+            return this.clear();
+          let prev = this.get(key);
+          const arg = asType(obj);
+          switch (arg.type) {
+            case "Undefined":
+              return this.del(key);
+            // synonym for 'removeItem'
+            case "Object":
+              prev ??= {};
+              return this.#upd(key, opt.merge ? Object.assign(prev, arg.value) : arg.value);
+            case "Array":
+              prev ??= [];
+              return this.#upd(key, opt.merge ? distinct(prev.concat(arg.value)) : obj);
+            case "Map":
+              prev ??= /* @__PURE__ */ new Map();
+              if (opt.merge) {
+                arg.value.forEach((val, key2) => prev.set(key2, val));
+                return this.#upd(key, prev);
+              }
+              return this.#upd(key, arg.value);
+            // else overwrite new Map
+            case "Set":
+              prev ??= /* @__PURE__ */ new Set();
+              if (opt.merge) {
+                arg.value.forEach((itm) => prev.add(itm));
+                return this.#upd(key, prev);
+              }
+              return this.#upd(key, arg.value);
+            // else overwrite new Set
+            default:
+              return this.#upd(key, arg.value);
+          }
+        }
+        /**
+         * Clear all items from this storage instance.
+         *
+         * @returns The WebStore instance for chaining
+         */
+        clear() {
+          try {
+            this.#exec((storage2) => storage2.clear());
+          } catch (e) {
+            console.warn("[WebStore] Failed to clear storage:", e);
+          }
+          return this;
+        }
+        /**
+         * Delete specific keys from storage.
+         *
+         * @param keys - The keys to remove
+         * @returns The WebStore instance for chaining
+         */
+        del(...keys) {
+          keys.forEach((key) => {
+            try {
+              this.#exec((storage2) => storage2.removeItem(stringify(key)));
+            } catch (e) {
+              console.warn(`[WebStore] Failed to removeItem for key '${String(key)}':`, e);
+            }
+          });
+          return this;
+        }
+        /**
+         * Get an array of keys currently in storage. If specific keys are provided, filters by those.
+         *
+         * @param keys - Optional keys to filter by
+         * @returns An array of string/symbol keys
+         */
+        keys(...keys) {
+          return this.entries(...keys).map(([key]) => key);
+        }
+        /**
+         * Get an array of values currently in storage.
+         *
+         * @param keys - Optional keys to retrieve values for
+         * @returns An array of parsed values
+         */
+        values(...keys) {
+          return this.entries(...keys).map(([, val]) => val);
+        }
+        /**
+         * Get an array of [key, value] entries currently in storage.
+         *
+         * @param keys - Optional keys to filter the entries by
+         * @returns An array of key-value tuples
+         */
+        entries(...keys) {
+          const wanted = new Set(keys.map((key) => stringify(key)));
+          const result = [];
+          this.#exec((storage2) => {
+            for (let i = 0; i < storage2.length; i++) {
+              const rawKey = storage2.key(i);
+              if (rawKey === null)
+                continue;
+              if (isEmpty(keys) || wanted.has(rawKey)) {
+                const rawVal = storage2.getItem(rawKey);
+                result.push([objectify(rawKey), objectify(rawVal)]);
+              }
+            }
+          });
+          return result;
+        }
+        /**
+         * Populate the storage from an existing object map.
+         *
+         * @param store - The object/dictionary to populate from
+         * @returns The WebStore instance for chaining
+         */
+        from(store) {
+          ownEntries(store).forEach(([key, val]) => this.set(key, val));
+          return this;
+        }
+        #upd(key, obj) {
+          try {
+            this.#exec((storage2) => storage2.setItem(stringify(key), stringify(obj)));
+          } catch (e) {
+            console.warn(`[WebStore] Failed to setItem for key '${String(key)}':`, e);
+          }
+          return this;
+        }
+      };
+      return WebStore2 = _classThis;
+    })();
+  }
+});
+
+// ../../library/dist/browser/mapper.library.js
+var mapper_library_exports = {};
+__export(mapper_library_exports, {
+  geoCoords: () => geoCoords,
+  geoLocation: () => geoLocation,
+  mapAddress: () => mapAddress,
+  mapHemisphere: () => mapHemisphere,
+  mapQuery: () => mapQuery
+});
+var defaults, context2, mapStore, MAP_KEY, log, storePromise, getStore, geoLocation, geoCoords, mapQuery, mapHemisphere, mapAddress;
+var init_mapper_library = __esm({
+  "../../library/dist/browser/mapper.library.js"() {
+    "use strict";
+    init_object_library();
+    init_utility_library();
+    init_assertion_library();
+    init_temporal_library();
+    init_international_library();
+    init_logger_class();
+    defaults = { catch: true, debug: 0 };
+    context2 = getContext();
+    mapStore = {};
+    MAP_KEY = "_magma_browser_map_";
+    log = new Logger("[Mapper]");
+    storePromise = null;
+    getStore = () => {
+      if (!storePromise) {
+        storePromise = new Promise((resolve, reject) => {
+          if (context2.type === CONTEXT.Browser) {
+            Promise.resolve().then(() => (init_webstore_class(), webstore_class_exports)).then(({ WebStore: WebStore2 }) => {
+              const local = new WebStore2("local");
+              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 {
+            resolve(void 0);
+          }
+        });
+      }
+      return storePromise;
+    };
+    geoLocation = (opts = {}) => getStore().then(() => new Promise((resolve, reject) => {
+      opts = Object.assign({}, defaults, opts);
+      const fulfil = opts.catch ? resolve : reject;
+      if (typeof navigator !== "undefined" && "geolocation" in navigator) {
+        navigator["geolocation"].getCurrentPosition((value2) => {
+          const coords = mapStore.geolocation?.coords;
+          const prevLat = coords?.latitude?.toFixed(3);
+          const prevLng = coords?.longitude?.toFixed(3);
+          const prevTime = mapStore.geolocation?.timestamp ?? 0;
+          const test1 = value2.coords.latitude.toFixed(3) !== prevLat;
+          const test2 = value2.coords.longitude.toFixed(3) !== prevLng;
+          const test3 = prevTime < instant().epochMilliseconds - 36e5;
+          if (test1 || test2 || test3) {
+            Object.assign(mapStore, { georesponse: null });
+            log.info(opts, "GeoLocation: device update");
+          }
+          Object.assign(mapStore, { geolocation: asObject(value2) });
+          resolve(mapStore.geolocation);
+        }, (error) => {
+          Object.assign(mapStore, { geolocation: { error: error.message }, georesponse: null });
+          fulfil(mapStore.geolocation);
+        });
+      } else {
+        Object.assign(mapStore, { geolocation: { error: "Not Supported" }, georesponse: null });
+        fulfil(mapStore.geolocation);
+      }
+    })).finally(() => {
+      const fn = mapStore.geolocation?.error ? log.error : log.info;
+      fn(opts, "geoLocation: ", mapStore.geolocation);
+      getStore().then((store) => store?.set(MAP_KEY, mapStore));
+    });
+    geoCoords = (coords) => new Promise((resolve, reject) => {
+      if (!isNullish(coords))
+        return resolve(coords);
+      geoLocation().then(
+        (geo) => isNullish(geo.error) ? { location: { lat: geo.coords.latitude, lng: geo.coords.longitude } } : null
+        // unsuccessful geolocation
+      ).then((loc) => resolve(loc)).catch((err) => reject(err));
+    });
+    mapQuery = (coords, opts = {}) => getStore().then(() => new Promise((resolve, reject) => {
+      opts = Object.assign({}, defaults, opts);
+      const fulfil = opts.catch ? resolve : reject;
+      geoCoords(coords).then((loc) => {
+        switch (true) {
+          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");
+          case isNullish(coords): {
+            const test1 = mapStore.geolocation && mapStore.georesponse;
+            const test2 = isNullish(mapStore.geolocation?.error) && isNullish(mapStore.georesponse?.error);
+            if (test1 && test2) {
+              if (opts.debug)
+                log.debug(opts, "mapQuery: cache");
+              return resolve(mapStore.georesponse);
+            }
+          }
+          // drop through to default:
+          default:
+            new window["google"]["maps"].Geocoder().geocode(loc).then((res) => resolve(mapStore.georesponse = asObject(res)));
+        }
+      }).catch((error) => {
+        Object.assign(mapStore, { georesponse: { error: error.message } });
+        fulfil(mapStore.georesponse);
+      });
+    })).finally(() => {
+      if (opts.debug) {
+        const fn = mapStore.georesponse?.error ? log.error : log.debug;
+        fn(opts, "mapQuery: ", mapStore.georesponse);
+      }
+      getStore().then((store) => store?.set(MAP_KEY, mapStore));
+    });
+    mapHemisphere = (coords, opts = {}) => mapQuery(coords, opts).then((response) => {
+      opts = Object.assign({}, defaults, opts);
+      if (isNullish(response.error)) {
+        if (opts.debug)
+          log.debug(opts, "sphere: ", response);
+        return response.results[0].geometry.location.lat() >= 0 ? "north" : "south";
+      }
+      const sphere = getHemisphere();
+      if (isNullish(sphere) && opts.catch === false)
+        throw new Error("Cannot determine Hemisphere");
+      return sphere;
+    }).catch((error) => {
+      if (opts.debug)
+        log.warn(opts, "mapHemisphere: ", error.message);
+      if (opts.catch === false)
+        throw error;
+      return null;
+    });
+    mapAddress = (coords, opts = {}) => mapQuery(coords, opts).then((response) => {
+      if (!isNullish(response.error))
+        throw new Error(response.error);
+      return response.results[0];
+    }).then(({ formatted_address, address_components }) => address_components.reduce((acc, itm) => {
+      itm.types.filter((type) => type !== "political").forEach((type) => acc[type] = (acc[type] ? acc[type] + "," : "").concat(itm.short_name));
+      return acc;
+    }, { formatted_address })).catch((error) => {
+      opts = Object.assign({}, defaults, opts);
+      if (opts.debug)
+        log.warn(opts, "mapAddress: ", error.message);
+      if (opts.catch === false)
+        throw error;
+      return null;
+    });
+  }
+});
+
+// ../../library/dist/common/runtime/request.library.js
+var request_library_exports = {};
+__export(request_library_exports, {
+  HTTP: () => HTTP,
+  HttpError: () => HttpError,
+  METHOD: () => METHOD,
+  fetchHead: () => fetchHead,
+  fetchRequest: () => fetchRequest
+});
+var TWO_SECONDS, RE_TRAILING_CLOSURE, HTTP, METHOD, HttpError, readBoundedBody, fetchRequest, fetchHead;
+var init_request_library = __esm({
+  "../../library/dist/common/runtime/request.library.js"() {
+    "use strict";
+    init_assertion_library();
+    TWO_SECONDS = 2e3;
+    RE_TRAILING_CLOSURE = /\);?$/;
+    HTTP = {
+      Ok: 200,
+      PermRedirect: 301,
+      TempRedirect: 302,
+      BadRequest: 400,
+      Unauthorised: 401,
+      Forbidden: 403
+    };
+    METHOD = {
+      Head: "HEAD",
+      Get: "GET",
+      Put: "PUT",
+      Delete: "DELETE",
+      Post: "POST"
+    };
+    HttpError = class extends Error {
+      status;
+      statusText;
+      body;
+      constructor(status, statusText, body) {
+        super(`${status}: ${statusText}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = "HttpError";
+      }
+    };
+    readBoundedBody = async (res, maxBytes) => {
+      const contentLength = res.headers?.get?.("Content-Length") || res.headers?.get?.("content-length");
+      if (contentLength) {
+        const bytes = parseInt(contentLength, 10);
+        if (isNumber(bytes) && bytes > maxBytes) {
+          try {
+            await res.body?.cancel();
+          } catch {
+          }
+          throw new HttpError(413, `Content-Length (${bytes}) exceeds limit (${maxBytes} bytes)`, null);
+        }
+      }
+      if (!res.body) {
+        let rawText2;
+        if (isFunction(res.text)) {
+          rawText2 = await res.text();
+        } else if (isFunction(res.json)) {
+          const obj = await res.json();
+          rawText2 = JSON.stringify(obj) ?? "";
+        } else {
+          rawText2 = "";
+        }
+        const byteLength = new TextEncoder().encode(rawText2).byteLength;
+        if (byteLength > maxBytes)
+          throw new HttpError(413, `Payload length (${byteLength}) exceeds limit (${maxBytes} bytes)`, null);
+        return rawText2;
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let totalBytes = 0;
+      let rawText = "";
+      try {
+        while (true) {
+          const { done, value: value2 } = await reader.read();
+          if (done)
+            break;
+          if (value2) {
+            totalBytes += value2.byteLength;
+            if (totalBytes > maxBytes) {
+              try {
+                await reader.cancel();
+              } catch {
+              }
+              throw new HttpError(413, `Streamed payload exceeded limit (${maxBytes} bytes)`, null);
+            }
+            rawText += decoder.decode(value2, { stream: true });
+          }
+        }
+        rawText += decoder.decode();
+        return rawText;
+      } finally {
+        try {
+          reader.releaseLock();
+        } catch {
+        }
+      }
+    };
+    fetchRequest = (url, init = {}, config = {}) => {
+      const signallingInit = {
+        ...init,
+        signal: init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(config.timeout ?? TWO_SECONDS)]) : AbortSignal.timeout(config.timeout ?? TWO_SECONDS)
+      };
+      return fetch(url, signallingInit).then(async (res) => {
+        if (res.ok) {
+          const contentType = res.headers?.get?.("Content-Type") || res.headers?.get?.("content-type") || "";
+          const isJson = contentType.includes("application/json");
+          if (isDefined(config.maxBytes)) {
+            const rawText = await readBoundedBody(res, config.maxBytes);
+            if (config.rawText)
+              return rawText;
+            if (config.prefix) {
+              const json = rawText.startsWith(config.prefix) ? rawText.substring(config.prefix.length).replace(RE_TRAILING_CLOSURE, "") : rawText;
+              return JSON.parse(json);
+            }
+            if (isJson)
+              return JSON.parse(rawText);
+            try {
+              return JSON.parse(rawText);
+            } catch {
+              return rawText;
+            }
+          }
+          if (config.rawText) {
+            const text = isFunction(res.text) ? await res.text() : "";
+            return text;
+          }
+          if (config.prefix) {
+            const rawPrefixText = await res.text();
+            const json = rawPrefixText.startsWith(config.prefix) ? rawPrefixText.substring(config.prefix.length).replace(RE_TRAILING_CLOSURE, "") : rawPrefixText;
+            return JSON.parse(json);
+          }
+          if (isFunction(res.text)) {
+            const text = await res.text();
+            try {
+              return JSON.parse(text);
+            } catch {
+              return text;
+            }
+          }
+          if (isFunction(res.json))
+            return await res.json();
+          return "";
+        }
+        let errorBody = null;
+        try {
+          const errorText = isDefined(config.maxBytes) ? await readBoundedBody(res, config.maxBytes) : isFunction(res.text) ? await res.text() : "";
+          try {
+            errorBody = JSON.parse(errorText);
+          } catch {
+            errorBody = errorText;
+          }
+        } catch (err) {
+          if (err instanceof HttpError && err.status === 413)
+            throw err;
+        }
+        throw new HttpError(res.status, res.statusText, errorBody);
+      });
+    };
+    fetchHead = (url) => {
+      const signal = AbortSignal.timeout(TWO_SECONDS);
+      const init = { method: METHOD.Head, signal };
+      return fetch(url, init).then(({ ok, status, statusText, headers }) => {
+        if (ok || status === HTTP.Forbidden)
+          return { status, headers };
+        throw new HttpError(status, statusText, null);
+      });
+    };
+  }
+});
+
+// ../../library/dist/server/mapper.library.js
+var mapper_library_exports2 = {};
+__export(mapper_library_exports2, {
+  serverGeoCoords: () => serverGeoCoords,
+  serverGeoLocation: () => serverGeoLocation,
+  serverMapHemisphere: () => 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";
+    init_assertion_library();
+    init_international_library();
+    init_logger_class();
+    log2 = new Logger("[ServerMapper]");
+    DEFAULT_GEO_ENDPOINT = "https://ipwho.is";
+    defaults2 = {
+      endpoint: `${DEFAULT_GEO_ENDPOINT}/`,
+      timeout: 3e3,
+      catch: true,
+      debug: 0
+    };
+    requestModulePromise = null;
+    getRequestModule = () => {
+      if (!requestModulePromise)
+        requestModulePromise = Promise.resolve().then(() => (init_request_library(), request_library_exports));
+      return requestModulePromise;
+    };
+    serverGeoLocation = async (opts = {}) => {
+      const options = { ...defaults2, ...opts };
+      const fulfil = options.catch !== false;
+      try {
+        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 });
+        if (typeof data !== "object" || isNullish(data))
+          throw new Error("Geolocation lookup failed");
+        if (data.status === "fail" || data.success === false)
+          throw new Error(data.message || data.reason || "Geolocation lookup failed");
+        const lat = isNumber(data.lat) ? data.lat : data.latitude;
+        const lng = isNumber(data.lon) ? data.lon : data.lng ?? data.longitude;
+        if (!isNumber(lat) || !isNumber(lng))
+          throw new Error("Geolocation lookup failed");
+        const tz = isString(data.timezone) ? data.timezone : data.timezone?.id ?? data.timeZone;
+        const result = {
+          lat,
+          lng,
+          latitude: lat,
+          longitude: lng,
+          ...isString(data.country || data.countryName || data.country_name) ? { country: data.country || data.countryName || data.country_name } : {},
+          ...isString(data.city || data.cityName || data.city_name) ? { city: data.city || data.cityName || data.city_name } : {},
+          ...isString(tz) ? { timezone: tz } : {},
+          ...isString(data.query || data.ip || data.ip_address) ? { query: data.query || data.ip || data.ip_address } : {},
+          status: "success"
+        };
+        if (options.debug)
+          log2.info(options, "serverGeoLocation success: ", result);
+        return result;
+      } catch (err) {
+        const errorMsg = err?.message || "Server geolocation error";
+        if (options.debug)
+          log2.error(options, "serverGeoLocation error: ", errorMsg);
+        if (!fulfil)
+          throw err;
+        return { error: errorMsg, status: "fail" };
+      }
+    };
+    serverGeoCoords = async (coords, opts) => {
+      if (!isNullish(coords)) {
+        const lat = coords.latitude ?? coords.lat;
+        const lng = coords.longitude ?? coords.lng ?? coords.lon ?? coords.long;
+        if (isNumber(lat) && isNumber(lng))
+          return { lat, lng };
+      }
+      const geo = await serverGeoLocation(opts);
+      if (isNullish(geo.error) && isNumber(geo.lat) && isNumber(geo.lng))
+        return { lat: geo.lat, lng: geo.lng };
+      return null;
+    };
+    serverMapHemisphere = async (coords, opts) => {
+      const resolved = await serverGeoCoords(coords, opts);
+      if (resolved)
+        return resolved.lat >= 0 ? "north" : "south";
+      return getHemisphere() ?? null;
+    };
+  }
+});
+
+// auto-inject-version:@magmacomputing/tempo/plugin/sdk
+var sdk_exports = {};
+__export(sdk_exports, {
+  definePlugin: () => definePlugin,
+  defineTerm: () => defineTerm
+});
+__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: "1.2.0" });
+var defineTerm = (config) => originalTerm({ ...config, version: "1.2.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 (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 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 = {};
+  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 = 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 (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 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 {
+  }
+  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 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));
+      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 {
+      ...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 {
+      ...stashed,
+      lat: stashed.latitude,
+      lng: stashed.longitude
+    };
+  const lookup = await geoLookup(opts);
+  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, 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 effectiveOpts = getEffectiveOptions(opts, this);
+      const setTimezone = effectiveOpts?.setTimezone !== false;
+      const coords = await resolveGeoCoordinates(this, effectiveOpts);
+      if (coords) {
+        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, 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;
+
+// src/install.ts
+(0, sdk_exports.autoInstall)(GeoPlugin);
+export {
+  GEO_PROPERTIES,
+  GeoPlugin,
+  clearStashedGeo,
+  coerceGeo,
+  index_default as default,
+  geoLocation,
+  geoLookup,
+  geoPlugin,
+  getStashedGeo,
+  haversineDistance,
+  resolveGeoCoordinates,
+  serverGeoCoords,
+  serverGeoLocation,
+  serverMapHemisphere,
+  solarOffset,
+  stashGeo
+};