@jxsuite/studio 2.4.3 → 3.0.0

package/dist/chunks/studio-qpfq7xhm.js

@@ -0,0 +1,1802 @@
+import {
+  getPlatform,
+  hasPlatform
+} from "./studio-sas7mt3k.js";
+
+// ../../node_modules/@vue/shared/dist/shared.esm-bundler.js
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(","))
+    map[key] = 1;
+  return (val) => (val in map);
+}
+var EMPTY_OBJ = Object.freeze({});
+var EMPTY_ARR = Object.freeze([]);
+var extend = Object.assign;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+var isArray = Array.isArray;
+var isMap = (val) => toTypeString(val) === "[object Map]";
+var isFunction = (val) => typeof val === "function";
+var isString = (val) => typeof val === "string";
+var isSymbol = (val) => typeof val === "symbol";
+var isObject = (val) => val !== null && typeof val === "object";
+var objectToString = Object.prototype.toString;
+var toTypeString = (value) => objectToString.call(value);
+var toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+var cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+var camelizeRE = /-\w/g;
+var camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+});
+var hyphenateRE = /\B([A-Z])/g;
+var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+var capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+var toHandlerKey = cacheStringFunction((str) => {
+  const s = str ? `on${capitalize(str)}` : ``;
+  return s;
+});
+var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
+
+// ../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+function warn(msg, ...args) {
+  console.warn(`[Vue warn] ${msg}`, ...args);
+}
+var activeEffectScope;
+
+class EffectScope {
+  constructor(detached = false) {
+    this.detached = detached;
+    this._active = true;
+    this._on = 0;
+    this.effects = [];
+    this.cleanups = [];
+    this._isPaused = false;
+    this._warnOnRun = true;
+    this.__v_skip = true;
+    if (!detached && activeEffectScope) {
+      if (activeEffectScope.active) {
+        this.parent = activeEffectScope;
+        this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
+      } else {
+        this._active = false;
+        this._warnOnRun = false;
+      }
+    }
+  }
+  get active() {
+    return this._active;
+  }
+  pause() {
+    if (this._active) {
+      this._isPaused = true;
+      let i, l;
+      if (this.scopes) {
+        const scopes = this.scopes.slice();
+        for (i = 0, l = scopes.length;i < l; i++) {
+          scopes[i].pause();
+        }
+      }
+      for (i = 0, l = this.effects.length;i < l; i++) {
+        this.effects[i].pause();
+      }
+    }
+  }
+  resume() {
+    if (this._active) {
+      if (this._isPaused) {
+        this._isPaused = false;
+        let i, l;
+        if (this.scopes) {
+          const scopes = this.scopes.slice();
+          for (i = 0, l = scopes.length;i < l; i++) {
+            scopes[i].resume();
+          }
+        }
+        const effects = this.effects.slice();
+        for (i = 0, l = effects.length;i < l; i++) {
+          effects[i].resume();
+        }
+      }
+    }
+  }
+  run(fn) {
+    if (this._active) {
+      const currentEffectScope = activeEffectScope;
+      try {
+        activeEffectScope = this;
+        return fn();
+      } finally {
+        activeEffectScope = currentEffectScope;
+      }
+    } else if (this._warnOnRun) {
+      warn(`cannot run an inactive effect scope.`);
+    }
+  }
+  on() {
+    if (++this._on === 1) {
+      this.prevScope = activeEffectScope;
+      activeEffectScope = this;
+    }
+  }
+  off() {
+    if (this._on > 0 && --this._on === 0) {
+      if (activeEffectScope === this) {
+        activeEffectScope = this.prevScope;
+      } else {
+        let current = activeEffectScope;
+        while (current) {
+          if (current.prevScope === this) {
+            current.prevScope = this.prevScope;
+            break;
+          }
+          current = current.prevScope;
+        }
+      }
+      this.prevScope = undefined;
+    }
+  }
+  stop(fromParent) {
+    if (this._active) {
+      this._active = false;
+      let i, l;
+      for (i = 0, l = this.effects.length;i < l; i++) {
+        this.effects[i].stop();
+      }
+      this.effects.length = 0;
+      for (i = 0, l = this.cleanups.length;i < l; i++) {
+        this.cleanups[i]();
+      }
+      this.cleanups.length = 0;
+      if (this.scopes) {
+        const scopes = this.scopes.slice();
+        for (i = 0, l = scopes.length;i < l; i++) {
+          scopes[i].stop(true);
+        }
+        this.scopes.length = 0;
+      }
+      if (!this.detached && this.parent && !fromParent) {
+        const last = this.parent.scopes.pop();
+        if (last && last !== this) {
+          this.parent.scopes[this.index] = last;
+          last.index = this.index;
+        }
+      }
+      this.parent = undefined;
+    }
+  }
+}
+function effectScope(detached) {
+  return new EffectScope(detached);
+}
+function onScopeDispose(fn, failSilently = false) {
+  if (activeEffectScope) {
+    activeEffectScope.cleanups.push(fn);
+  } else if (!failSilently) {
+    warn(`onScopeDispose() is called when there is no active effect scope to be associated with.`);
+  }
+}
+var activeSub;
+var pausedQueueEffects = /* @__PURE__ */ new WeakSet;
+
+class ReactiveEffect {
+  constructor(fn) {
+    this.fn = fn;
+    this.deps = undefined;
+    this.depsTail = undefined;
+    this.flags = 1 | 4;
+    this.next = undefined;
+    this.cleanup = undefined;
+    this.scheduler = undefined;
+    if (activeEffectScope) {
+      if (activeEffectScope.active) {
+        activeEffectScope.effects.push(this);
+      } else {
+        this.flags &= -2;
+      }
+    }
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    if (this.flags & 64) {
+      this.flags &= -65;
+      if (pausedQueueEffects.has(this)) {
+        pausedQueueEffects.delete(this);
+        this.trigger();
+      }
+    }
+  }
+  notify() {
+    if (this.flags & 2 && !(this.flags & 32)) {
+      return;
+    }
+    if (!(this.flags & 8)) {
+      batch(this);
+    }
+  }
+  run() {
+    if (!(this.flags & 1)) {
+      return this.fn();
+    }
+    this.flags |= 2;
+    cleanupEffect(this);
+    prepareDeps(this);
+    const prevEffect = activeSub;
+    const prevShouldTrack = shouldTrack;
+    activeSub = this;
+    shouldTrack = true;
+    try {
+      return this.fn();
+    } finally {
+      if (activeSub !== this) {
+        warn("Active effect was not restored correctly - this is likely a Vue internal bug.");
+      }
+      cleanupDeps(this);
+      activeSub = prevEffect;
+      shouldTrack = prevShouldTrack;
+      this.flags &= -3;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let link = this.deps;link; link = link.nextDep) {
+        removeSub(link);
+      }
+      this.deps = this.depsTail = undefined;
+      cleanupEffect(this);
+      this.onStop && this.onStop();
+      this.flags &= -2;
+    }
+  }
+  trigger() {
+    if (this.flags & 64) {
+      pausedQueueEffects.add(this);
+    } else if (this.scheduler) {
+      this.scheduler();
+    } else {
+      this.runIfDirty();
+    }
+  }
+  runIfDirty() {
+    if (isDirty(this)) {
+      this.run();
+    }
+  }
+  get dirty() {
+    return isDirty(this);
+  }
+}
+var batchDepth = 0;
+var batchedSub;
+var batchedComputed;
+function batch(sub, isComputed = false) {
+  sub.flags |= 8;
+  if (isComputed) {
+    sub.next = batchedComputed;
+    batchedComputed = sub;
+    return;
+  }
+  sub.next = batchedSub;
+  batchedSub = sub;
+}
+function startBatch() {
+  batchDepth++;
+}
+function endBatch() {
+  if (--batchDepth > 0) {
+    return;
+  }
+  if (batchedComputed) {
+    let e = batchedComputed;
+    batchedComputed = undefined;
+    while (e) {
+      const next = e.next;
+      e.next = undefined;
+      e.flags &= -9;
+      e = next;
+    }
+  }
+  let error;
+  while (batchedSub) {
+    let e = batchedSub;
+    batchedSub = undefined;
+    while (e) {
+      const next = e.next;
+      e.next = undefined;
+      e.flags &= -9;
+      if (e.flags & 1) {
+        try {
+          e.trigger();
+        } catch (err) {
+          if (!error)
+            error = err;
+        }
+      }
+      e = next;
+    }
+  }
+  if (error)
+    throw error;
+}
+function prepareDeps(sub) {
+  for (let link = sub.deps;link; link = link.nextDep) {
+    link.version = -1;
+    link.prevActiveLink = link.dep.activeLink;
+    link.dep.activeLink = link;
+  }
+}
+function cleanupDeps(sub) {
+  let head;
+  let tail = sub.depsTail;
+  let link = tail;
+  while (link) {
+    const prev = link.prevDep;
+    if (link.version === -1) {
+      if (link === tail)
+        tail = prev;
+      removeSub(link);
+      removeDep(link);
+    } else {
+      head = link;
+    }
+    link.dep.activeLink = link.prevActiveLink;
+    link.prevActiveLink = undefined;
+    link = prev;
+  }
+  sub.deps = head;
+  sub.depsTail = tail;
+}
+function isDirty(sub) {
+  for (let link = sub.deps;link; link = link.nextDep) {
+    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
+      return true;
+    }
+  }
+  if (sub._dirty) {
+    return true;
+  }
+  return false;
+}
+function refreshComputed(computed) {
+  if (computed.flags & 4 && !(computed.flags & 16)) {
+    return;
+  }
+  computed.flags &= -17;
+  if (computed.globalVersion === globalVersion) {
+    return;
+  }
+  computed.globalVersion = globalVersion;
+  if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) {
+    return;
+  }
+  computed.flags |= 2;
+  const dep = computed.dep;
+  const prevSub = activeSub;
+  const prevShouldTrack = shouldTrack;
+  activeSub = computed;
+  shouldTrack = true;
+  try {
+    prepareDeps(computed);
+    const value = computed.fn(computed._value);
+    if (dep.version === 0 || hasChanged(value, computed._value)) {
+      computed.flags |= 128;
+      computed._value = value;
+      dep.version++;
+    }
+  } catch (err) {
+    dep.version++;
+    throw err;
+  } finally {
+    activeSub = prevSub;
+    shouldTrack = prevShouldTrack;
+    cleanupDeps(computed);
+    computed.flags &= -3;
+  }
+}
+function removeSub(link, soft = false) {
+  const { dep, prevSub, nextSub } = link;
+  if (prevSub) {
+    prevSub.nextSub = nextSub;
+    link.prevSub = undefined;
+  }
+  if (nextSub) {
+    nextSub.prevSub = prevSub;
+    link.nextSub = undefined;
+  }
+  if (dep.subsHead === link) {
+    dep.subsHead = nextSub;
+  }
+  if (dep.subs === link) {
+    dep.subs = prevSub;
+    if (!prevSub && dep.computed) {
+      dep.computed.flags &= -5;
+      for (let l = dep.computed.deps;l; l = l.nextDep) {
+        removeSub(l, true);
+      }
+    }
+  }
+  if (!soft && !--dep.sc && dep.map) {
+    dep.map.delete(dep.key);
+  }
+}
+function removeDep(link) {
+  const { prevDep, nextDep } = link;
+  if (prevDep) {
+    prevDep.nextDep = nextDep;
+    link.prevDep = undefined;
+  }
+  if (nextDep) {
+    nextDep.prevDep = prevDep;
+    link.nextDep = undefined;
+  }
+}
+function effect(fn, options) {
+  if (fn.effect instanceof ReactiveEffect) {
+    fn = fn.effect.fn;
+  }
+  const e = new ReactiveEffect(fn);
+  if (options) {
+    extend(e, options);
+  }
+  try {
+    e.run();
+  } catch (err) {
+    e.stop();
+    throw err;
+  }
+  const runner = e.run.bind(e);
+  runner.effect = e;
+  return runner;
+}
+var shouldTrack = true;
+var trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === undefined ? true : last;
+}
+function onEffectCleanup(fn, failSilently = false) {
+  if (activeSub instanceof ReactiveEffect) {
+    activeSub.cleanup = fn;
+  } else if (!failSilently) {
+    warn(`onEffectCleanup() was called when there was no active effect to associate with.`);
+  }
+}
+function cleanupEffect(e) {
+  const { cleanup } = e;
+  e.cleanup = undefined;
+  if (cleanup) {
+    const prevSub = activeSub;
+    activeSub = undefined;
+    try {
+      cleanup();
+    } finally {
+      activeSub = prevSub;
+    }
+  }
+}
+var globalVersion = 0;
+
+class Link {
+  constructor(sub, dep) {
+    this.sub = sub;
+    this.dep = dep;
+    this.version = dep.version;
+    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = undefined;
+  }
+}
+
+class Dep {
+  constructor(computed) {
+    this.computed = computed;
+    this.version = 0;
+    this.activeLink = undefined;
+    this.subs = undefined;
+    this.map = undefined;
+    this.key = undefined;
+    this.sc = 0;
+    this.__v_skip = true;
+    if (true) {
+      this.subsHead = undefined;
+    }
+  }
+  track(debugInfo) {
+    if (!activeSub || !shouldTrack || activeSub === this.computed) {
+      return;
+    }
+    let link = this.activeLink;
+    if (link === undefined || link.sub !== activeSub) {
+      link = this.activeLink = new Link(activeSub, this);
+      if (!activeSub.deps) {
+        activeSub.deps = activeSub.depsTail = link;
+      } else {
+        link.prevDep = activeSub.depsTail;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+      }
+      addSub(link);
+    } else if (link.version === -1) {
+      link.version = this.version;
+      if (link.nextDep) {
+        const next = link.nextDep;
+        next.prevDep = link.prevDep;
+        if (link.prevDep) {
+          link.prevDep.nextDep = next;
+        }
+        link.prevDep = activeSub.depsTail;
+        link.nextDep = undefined;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+        if (activeSub.deps === link) {
+          activeSub.deps = next;
+        }
+      }
+    }
+    if (activeSub.onTrack) {
+      activeSub.onTrack(extend({
+        effect: activeSub
+      }, debugInfo));
+    }
+    return link;
+  }
+  trigger(debugInfo) {
+    this.version++;
+    globalVersion++;
+    this.notify(debugInfo);
+  }
+  notify(debugInfo) {
+    startBatch();
+    try {
+      if (true) {
+        for (let head = this.subsHead;head; head = head.nextSub) {
+          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
+            head.sub.onTrigger(extend({
+              effect: head.sub
+            }, debugInfo));
+          }
+        }
+      }
+      for (let link = this.subs;link; link = link.prevSub) {
+        if (link.sub.notify()) {
+          link.sub.dep.notify();
+        }
+      }
+    } finally {
+      endBatch();
+    }
+  }
+}
+function addSub(link) {
+  link.dep.sc++;
+  if (link.sub.flags & 4) {
+    const computed = link.dep.computed;
+    if (computed && !link.dep.subs) {
+      computed.flags |= 4 | 16;
+      for (let l = computed.deps;l; l = l.nextDep) {
+        addSub(l);
+      }
+    }
+    const currentTail = link.dep.subs;
+    if (currentTail !== link) {
+      link.prevSub = currentTail;
+      if (currentTail)
+        currentTail.nextSub = link;
+    }
+    if (link.dep.subsHead === undefined) {
+      link.dep.subsHead = link;
+    }
+    link.dep.subs = link;
+  }
+}
+var targetMap = /* @__PURE__ */ new WeakMap;
+var ITERATE_KEY = /* @__PURE__ */ Symbol("Object iterate");
+var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol("Map keys iterate");
+var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol("Array iterate");
+function track(target, type, key) {
+  if (shouldTrack && activeSub) {
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+      targetMap.set(target, depsMap = /* @__PURE__ */ new Map);
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+      depsMap.set(key, dep = new Dep);
+      dep.map = depsMap;
+      dep.key = key;
+    }
+    if (true) {
+      dep.track({
+        target,
+        type,
+        key
+      });
+    }
+  }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    globalVersion++;
+    return;
+  }
+  const run = (dep) => {
+    if (dep) {
+      if (true) {
+        dep.trigger({
+          target,
+          type,
+          key,
+          newValue,
+          oldValue,
+          oldTarget
+        });
+      }
+    }
+  };
+  startBatch();
+  if (type === "clear") {
+    depsMap.forEach(run);
+  } else {
+    const targetIsArray = isArray(target);
+    const isArrayIndex = targetIsArray && isIntegerKey(key);
+    if (targetIsArray && key === "length") {
+      const newLength = Number(newValue);
+      depsMap.forEach((dep, key2) => {
+        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+          run(dep);
+        }
+      });
+    } else {
+      if (key !== undefined || depsMap.has(undefined)) {
+        run(depsMap.get(key));
+      }
+      if (isArrayIndex) {
+        run(depsMap.get(ARRAY_ITERATE_KEY));
+      }
+      switch (type) {
+        case "add":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          } else if (isArrayIndex) {
+            run(depsMap.get("length"));
+          }
+          break;
+        case "delete":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          }
+          break;
+        case "set":
+          if (isMap(target)) {
+            run(depsMap.get(ITERATE_KEY));
+          }
+          break;
+      }
+    }
+  }
+  endBatch();
+}
+function reactiveReadArray(array) {
+  const raw = toRaw(array);
+  if (raw === array)
+    return raw;
+  track(raw, "iterate", ARRAY_ITERATE_KEY);
+  return isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+  track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+  return arr;
+}
+function toWrapped(target, item) {
+  if (isReadonly(target)) {
+    return isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
+  }
+  return toReactive(item);
+}
+var arrayInstrumentations = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
+  },
+  concat(...args) {
+    return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
+  },
+  entries() {
+    return iterator(this, "entries", (value) => {
+      value[1] = toWrapped(this, value[1]);
+      return value;
+    });
+  },
+  every(fn, thisArg) {
+    return apply(this, "every", fn, thisArg, undefined, arguments);
+  },
+  filter(fn, thisArg) {
+    return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
+  },
+  find(fn, thisArg) {
+    return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
+  },
+  findIndex(fn, thisArg) {
+    return apply(this, "findIndex", fn, thisArg, undefined, arguments);
+  },
+  findLast(fn, thisArg) {
+    return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
+  },
+  findLastIndex(fn, thisArg) {
+    return apply(this, "findLastIndex", fn, thisArg, undefined, arguments);
+  },
+  forEach(fn, thisArg) {
+    return apply(this, "forEach", fn, thisArg, undefined, arguments);
+  },
+  includes(...args) {
+    return searchProxy(this, "includes", args);
+  },
+  indexOf(...args) {
+    return searchProxy(this, "indexOf", args);
+  },
+  join(separator) {
+    return reactiveReadArray(this).join(separator);
+  },
+  lastIndexOf(...args) {
+    return searchProxy(this, "lastIndexOf", args);
+  },
+  map(fn, thisArg) {
+    return apply(this, "map", fn, thisArg, undefined, arguments);
+  },
+  pop() {
+    return noTracking(this, "pop");
+  },
+  push(...args) {
+    return noTracking(this, "push", args);
+  },
+  reduce(fn, ...args) {
+    return reduce(this, "reduce", fn, args);
+  },
+  reduceRight(fn, ...args) {
+    return reduce(this, "reduceRight", fn, args);
+  },
+  shift() {
+    return noTracking(this, "shift");
+  },
+  some(fn, thisArg) {
+    return apply(this, "some", fn, thisArg, undefined, arguments);
+  },
+  splice(...args) {
+    return noTracking(this, "splice", args);
+  },
+  toReversed() {
+    return reactiveReadArray(this).toReversed();
+  },
+  toSorted(comparer) {
+    return reactiveReadArray(this).toSorted(comparer);
+  },
+  toSpliced(...args) {
+    return reactiveReadArray(this).toSpliced(...args);
+  },
+  unshift(...args) {
+    return noTracking(this, "unshift", args);
+  },
+  values() {
+    return iterator(this, "values", (item) => toWrapped(this, item));
+  }
+};
+function iterator(self2, method, wrapValue) {
+  const arr = shallowReadArray(self2);
+  const iter = arr[method]();
+  if (arr !== self2 && !isShallow(self2)) {
+    iter._next = iter.next;
+    iter.next = () => {
+      const result = iter._next();
+      if (!result.done) {
+        result.value = wrapValue(result.value);
+      }
+      return result;
+    };
+  }
+  return iter;
+}
+var arrayProto = Array.prototype;
+function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
+  const arr = shallowReadArray(self2);
+  const needsWrap = arr !== self2 && !isShallow(self2);
+  const methodFn = arr[method];
+  if (methodFn !== arrayProto[method]) {
+    const result2 = methodFn.apply(self2, args);
+    return needsWrap ? toReactive(result2) : result2;
+  }
+  let wrappedFn = fn;
+  if (arr !== self2) {
+    if (needsWrap) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, toWrapped(self2, item), index, self2);
+      };
+    } else if (fn.length > 2) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, item, index, self2);
+      };
+    }
+  }
+  const result = methodFn.call(arr, wrappedFn, thisArg);
+  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+}
+function reduce(self2, method, fn, args) {
+  const arr = shallowReadArray(self2);
+  const needsWrap = arr !== self2 && !isShallow(self2);
+  let wrappedFn = fn;
+  let wrapInitialAccumulator = false;
+  if (arr !== self2) {
+    if (needsWrap) {
+      wrapInitialAccumulator = args.length === 0;
+      wrappedFn = function(acc, item, index) {
+        if (wrapInitialAccumulator) {
+          wrapInitialAccumulator = false;
+          acc = toWrapped(self2, acc);
+        }
+        return fn.call(this, acc, toWrapped(self2, item), index, self2);
+      };
+    } else if (fn.length > 3) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, item, index, self2);
+      };
+    }
+  }
+  const result = arr[method](wrappedFn, ...args);
+  return wrapInitialAccumulator ? toWrapped(self2, result) : result;
+}
+function searchProxy(self2, method, args) {
+  const arr = toRaw(self2);
+  track(arr, "iterate", ARRAY_ITERATE_KEY);
+  const res = arr[method](...args);
+  if ((res === -1 || res === false) && isProxy(args[0])) {
+    args[0] = toRaw(args[0]);
+    return arr[method](...args);
+  }
+  return res;
+}
+function noTracking(self2, method, args = []) {
+  pauseTracking();
+  startBatch();
+  const res = toRaw(self2)[method].apply(self2, args);
+  endBatch();
+  resetTracking();
+  return res;
+}
+var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+var builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol));
+function hasOwnProperty2(key) {
+  if (!isSymbol(key))
+    key = String(key);
+  const obj = toRaw(this);
+  track(obj, "has", key);
+  return obj.hasOwnProperty(key);
+}
+
+class BaseReactiveHandler {
+  constructor(_isReadonly = false, _isShallow = false) {
+    this._isReadonly = _isReadonly;
+    this._isShallow = _isShallow;
+  }
+  get(target, key, receiver) {
+    if (key === "__v_skip")
+      return target["__v_skip"];
+    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return isShallow2;
+    } else if (key === "__v_raw") {
+      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+        return target;
+      }
+      return;
+    }
+    const targetIsArray = isArray(target);
+    if (!isReadonly2) {
+      let fn;
+      if (targetIsArray && (fn = arrayInstrumentations[key])) {
+        return fn;
+      }
+      if (key === "hasOwnProperty") {
+        return hasOwnProperty2;
+      }
+    }
+    const res = Reflect.get(target, key, isRef(target) ? target : receiver);
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (!isReadonly2) {
+      track(target, "get", key);
+    }
+    if (isShallow2) {
+      return res;
+    }
+    if (isRef(res)) {
+      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
+      return isReadonly2 && isObject(value) ? readonly(value) : value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? readonly(res) : reactive(res);
+    }
+    return res;
+  }
+}
+
+class MutableReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(false, isShallow2);
+  }
+  set(target, key, value, receiver) {
+    let oldValue = target[key];
+    const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
+    if (!this._isShallow) {
+      const isOldValueReadonly = isReadonly(oldValue);
+      if (!isShallow(value) && !isReadonly(value)) {
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+      }
+      if (!isArrayWithIntegerKey && isRef(oldValue) && !isRef(value)) {
+        if (isOldValueReadonly) {
+          if (true) {
+            warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
+          }
+          return true;
+        } else {
+          oldValue.value = value;
+          return true;
+        }
+      }
+    }
+    const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
+    if (target === toRaw(receiver) && result) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+    }
+    return result;
+  }
+  deleteProperty(target, key) {
+    const hadKey = hasOwn(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+      trigger(target, "delete", key, undefined, oldValue);
+    }
+    return result;
+  }
+  has(target, key) {
+    const result = Reflect.has(target, key);
+    if (!isSymbol(key) || !builtInSymbols.has(key)) {
+      track(target, "has", key);
+    }
+    return result;
+  }
+  ownKeys(target) {
+    track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+    return Reflect.ownKeys(target);
+  }
+}
+
+class ReadonlyReactiveHandler extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(true, isShallow2);
+  }
+  set(target, key) {
+    if (true) {
+      warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+    }
+    return true;
+  }
+  deleteProperty(target, key) {
+    if (true) {
+      warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+    }
+    return true;
+  }
+}
+var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler;
+var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler;
+var toShallow = (value) => value;
+var getProto = (v) => Reflect.getPrototypeOf(v);
+function createIterableMethod(method, isReadonly2, isShallow2) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const isKeyOnly = method === "keys" && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+    return extend(Object.create(innerIterator), {
+      next() {
+        const { value, done } = innerIterator.next();
+        return done ? { value, done } : {
+          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+          done
+        };
+      }
+    });
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    if (true) {
+      const key = args[0] ? `on key "${args[0]}" ` : ``;
+      warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+    }
+    return type === "delete" ? false : type === "clear" ? undefined : this;
+  };
+}
+function createInstrumentations(readonly, shallow) {
+  const instrumentations = {
+    get(key) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const rawKey = toRaw(key);
+      if (!readonly) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "get", key);
+        }
+        track(rawTarget, "get", rawKey);
+      }
+      const { has } = getProto(rawTarget);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      if (has.call(rawTarget, key)) {
+        return wrap(target.get(key));
+      } else if (has.call(rawTarget, rawKey)) {
+        return wrap(target.get(rawKey));
+      } else if (target !== rawTarget) {
+        target.get(key);
+      }
+    },
+    get size() {
+      const target = this["__v_raw"];
+      !readonly && track(toRaw(target), "iterate", ITERATE_KEY);
+      return target.size;
+    },
+    has(key) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const rawKey = toRaw(key);
+      if (!readonly) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "has", key);
+        }
+        track(rawTarget, "has", rawKey);
+      }
+      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+    },
+    forEach(callback, thisArg) {
+      const observed = this;
+      const target = observed["__v_raw"];
+      const rawTarget = toRaw(target);
+      const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+      !readonly && track(rawTarget, "iterate", ITERATE_KEY);
+      return target.forEach((value, key) => {
+        return callback.call(thisArg, wrap(value), wrap(key), observed);
+      });
+    }
+  };
+  extend(instrumentations, readonly ? {
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear")
+  } : {
+    add(value) {
+      const target = toRaw(this);
+      const proto = getProto(target);
+      const rawValue = toRaw(value);
+      const valueToAdd = !shallow && !isShallow(value) && !isReadonly(value) ? rawValue : value;
+      const hadKey = proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue);
+      if (!hadKey) {
+        target.add(valueToAdd);
+        trigger(target, "add", valueToAdd, valueToAdd);
+      }
+      return this;
+    },
+    set(key, value) {
+      if (!shallow && !isShallow(value) && !isReadonly(value)) {
+        value = toRaw(value);
+      }
+      const target = toRaw(this);
+      const { has, get } = getProto(target);
+      let hadKey = has.call(target, key);
+      if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+      } else if (true) {
+        checkIdentityKeys(target, has, key);
+      }
+      const oldValue = get.call(target, key);
+      target.set(key, value);
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+      return this;
+    },
+    delete(key) {
+      const target = toRaw(this);
+      const { has, get } = getProto(target);
+      let hadKey = has.call(target, key);
+      if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+      } else if (true) {
+        checkIdentityKeys(target, has, key);
+      }
+      const oldValue = get ? get.call(target, key) : undefined;
+      const result = target.delete(key);
+      if (hadKey) {
+        trigger(target, "delete", key, undefined, oldValue);
+      }
+      return result;
+    },
+    clear() {
+      const target = toRaw(this);
+      const hadItems = target.size !== 0;
+      const oldTarget = isMap(target) ? new Map(target) : new Set(target);
+      const result = target.clear();
+      if (hadItems) {
+        trigger(target, "clear", undefined, undefined, oldTarget);
+      }
+      return result;
+    }
+  });
+  const iteratorMethods = [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ];
+  iteratorMethods.forEach((method) => {
+    instrumentations[method] = createIterableMethod(method, readonly, shallow);
+  });
+  return instrumentations;
+}
+function createInstrumentationGetter(isReadonly2, shallow) {
+  const instrumentations = createInstrumentations(isReadonly2, shallow);
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+  };
+}
+var mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+var readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+function checkIdentityKeys(target, has, key) {
+  const rawKey = toRaw(key);
+  if (rawKey !== key && has.call(target, rawKey)) {
+    const type = toRawType(target);
+    warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
+  }
+}
+var reactiveMap = /* @__PURE__ */ new WeakMap;
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap;
+var readonlyMap = /* @__PURE__ */ new WeakMap;
+var shallowReadonlyMap = /* @__PURE__ */ new WeakMap;
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function reactive(target) {
+  if (/* @__PURE__ */ isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+function readonly(target) {
+  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    if (true) {
+      warn(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
+    }
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  if (target["__v_skip"] || !Object.isExtensible(target)) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const targetType = targetTypeMap(toRawType(target));
+  if (targetType === 0) {
+    return target;
+  }
+  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function isReactive(value) {
+  if (/* @__PURE__ */ isReadonly(value)) {
+    return /* @__PURE__ */ isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+  return value ? !!value["__v_raw"] : false;
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? /* @__PURE__ */ toRaw(raw) : observed;
+}
+var toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
+var toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+function isRef(r) {
+  return r ? r["__v_isRef"] === true : false;
+}
+function ref(value) {
+  return createRef(value, false);
+}
+function shallowRef(value) {
+  return createRef(value, true);
+}
+function createRef(rawValue, shallow) {
+  if (/* @__PURE__ */ isRef(rawValue)) {
+    return rawValue;
+  }
+  return new RefImpl(rawValue, shallow);
+}
+
+class RefImpl {
+  constructor(value, isShallow2) {
+    this.dep = new Dep;
+    this["__v_isRef"] = true;
+    this["__v_isShallow"] = false;
+    this._rawValue = isShallow2 ? value : toRaw(value);
+    this._value = isShallow2 ? value : toReactive(value);
+    this["__v_isShallow"] = isShallow2;
+  }
+  get value() {
+    if (true) {
+      this.dep.track({
+        target: this,
+        type: "get",
+        key: "value"
+      });
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    const oldValue = this._rawValue;
+    const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
+    newValue = useDirectValue ? newValue : toRaw(newValue);
+    if (hasChanged(newValue, oldValue)) {
+      this._rawValue = newValue;
+      this._value = useDirectValue ? newValue : toReactive(newValue);
+      if (true) {
+        this.dep.trigger({
+          target: this,
+          type: "set",
+          key: "value",
+          newValue,
+          oldValue
+        });
+      }
+    }
+  }
+}
+class ComputedRefImpl {
+  constructor(fn, setter, isSSR) {
+    this.fn = fn;
+    this.setter = setter;
+    this._value = undefined;
+    this.dep = new Dep(this);
+    this.__v_isRef = true;
+    this.deps = undefined;
+    this.depsTail = undefined;
+    this.flags = 16;
+    this.globalVersion = globalVersion - 1;
+    this.next = undefined;
+    this.effect = this;
+    this["__v_isReadonly"] = !setter;
+    this.isSSR = isSSR;
+  }
+  notify() {
+    this.flags |= 16;
+    if (!(this.flags & 8) && activeSub !== this) {
+      batch(this, true);
+      return true;
+    } else if (true)
+      ;
+  }
+  get value() {
+    const link = this.dep.track({
+      target: this,
+      type: "get",
+      key: "value"
+    });
+    refreshComputed(this);
+    if (link) {
+      link.version = this.dep.version;
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    if (this.setter) {
+      this.setter(newValue);
+    } else if (true) {
+      warn("Write operation failed: computed value is readonly");
+    }
+  }
+}
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+  let getter;
+  let setter;
+  if (isFunction(getterOrOptions)) {
+    getter = getterOrOptions;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  const cRef = new ComputedRefImpl(getter, setter, isSSR);
+  if (debugOptions && !isSSR) {
+    cRef.onTrack = debugOptions.onTrack;
+    cRef.onTrigger = debugOptions.onTrigger;
+  }
+  return cRef;
+}
+// src/services/settings/definitions.ts
+function normalizeBaseUrl(raw) {
+  return raw.trim().replace(/\/+$/, "");
+}
+function trimmed(raw) {
+  return raw.trim();
+}
+var SETTINGS = {
+  aiBaseUrl: {
+    default: "",
+    key: "jx.ai.baseUrl",
+    normalize: normalizeBaseUrl,
+    scope: "user"
+  },
+  aiOpenAiKey: {
+    default: "",
+    key: "jx.ai.openaiKey",
+    normalize: trimmed,
+    scope: "user",
+    secret: true
+  },
+  aiModel: {
+    default: "gpt-4o",
+    key: "jx.ai.model",
+    normalize: trimmed,
+    scope: "user"
+  },
+  keybindings: {
+    default: "",
+    key: "jx.keybindings",
+    normalize: (raw) => raw.trim() === "{}" ? "" : raw.trim(),
+    scope: "user"
+  },
+  theme: {
+    default: "",
+    key: "jx-studio-theme",
+    normalize: trimmed,
+    scope: "user"
+  },
+  cfAccountId: {
+    default: "",
+    key: "jx.cf.accountId",
+    normalize: trimmed,
+    scope: "user"
+  },
+  cfToken: {
+    default: "",
+    key: "jx.cf.token",
+    normalize: trimmed,
+    scope: "user",
+    secret: true
+  }
+};
+var ALL_SETTINGS = Object.values(SETTINGS);
+var USER_SETTINGS = ALL_SETTINGS.filter((definition) => definition.scope === "user");
+var USER_SETTING_KEYS = USER_SETTINGS.map((definition) => definition.key);
+
+// src/services/clock.ts
+var _pinned = null;
+function now() {
+  return _pinned ?? Date.now();
+}
+function pinClock(at) {
+  const ms = at instanceof Date ? at.getTime() : typeof at === "number" ? at : Date.parse(at);
+  if (!Number.isFinite(ms)) {
+    throw new TypeError(`clock: cannot pin to ${JSON.stringify(at)}`);
+  }
+  _pinned = ms;
+  return ms;
+}
+
+// src/services/announce.ts
+var REGION_ID = {
+  assertive: "jx-live-assertive",
+  polite: "jx-live-polite"
+};
+function region(politeness) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const id = REGION_ID[politeness];
+  const existing = document.querySelector(`#${id}`);
+  if (existing) {
+    return existing;
+  }
+  const node = document.createElement("div");
+  node.id = id;
+  node.setAttribute("aria-live", politeness);
+  node.setAttribute("role", politeness === "assertive" ? "alert" : "status");
+  node.setAttribute("aria-atomic", "true");
+  node.style.cssText = "position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;" + "clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0";
+  document.body.append(node);
+  return node;
+}
+function announce(message, politeness = "polite") {
+  if (message === "") {
+    return;
+  }
+  const node = region(politeness);
+  if (!node) {
+    return;
+  }
+  node.textContent = "";
+  setTimeout(() => {
+    node.textContent = message;
+  }, 0);
+}
+
+// src/services/notify.ts
+var DEFAULT_TIER = {
+  error: "problem",
+  info: "toast",
+  success: "toast",
+  warn: "toast"
+};
+var TOAST_LIFETIME_MS = {
+  error: 8000,
+  info: 4000,
+  success: 4000,
+  warn: 8000
+};
+var _seq = 0;
+function nextId() {
+  _seq += 1;
+  return `n${_seq}`;
+}
+var toasts = reactive([]);
+var problems = reactive([]);
+var MAX_TOASTS = 4;
+function storeFor(tier) {
+  return tier === "problem" ? problems : toasts;
+}
+function notify(severity, message, options = {}) {
+  const tier = options.tier ?? DEFAULT_TIER[severity];
+  const record = {
+    at: now(),
+    id: nextId(),
+    message,
+    severity,
+    tier,
+    ...options.action === undefined ? {} : { action: options.action },
+    ...options.actionArgs === undefined ? {} : { actionArgs: options.actionArgs },
+    ...options.detail === undefined ? {} : { detail: options.detail },
+    ...options.source === undefined ? {} : { source: options.source },
+    ...options.path === undefined ? {} : { path: options.path },
+    ...options.key === undefined ? {} : { key: options.key },
+    ...tier === "toast" ? { timeoutMs: options.timeoutMs ?? TOAST_LIFETIME_MS[severity] } : {}
+  };
+  const store = storeFor(tier);
+  if (record.key !== undefined) {
+    const at = store.findIndex((existing) => existing.key === record.key);
+    if (at !== -1) {
+      store.splice(at, 1);
+    }
+  }
+  store.push(record);
+  if (tier === "toast") {
+    while (toasts.length > MAX_TOASTS) {
+      toasts.shift();
+    }
+  }
+  announce(record.source === undefined ? record.message : `${record.source}: ${record.message}`, severity === "error" ? "assertive" : "polite");
+  return record;
+}
+function severityHelper(severity) {
+  return (message, options = {}) => notify(severity, message, options);
+}
+notify.success = severityHelper("success");
+notify.info = severityHelper("info");
+notify.warn = severityHelper("warn");
+notify.error = severityHelper("error");
+function dismiss(id) {
+  for (const store of [toasts, problems]) {
+    const at = store.findIndex((record) => record.id === id);
+    if (at !== -1) {
+      store.splice(at, 1);
+      return true;
+    }
+  }
+  return false;
+}
+function clearProblems(match) {
+  const kept = match ? problems.filter((record) => !match(record)) : [];
+  const removed = problems.length - kept.length;
+  problems.splice(0, problems.length, ...kept);
+  return removed;
+}
+function problemCount(severity) {
+  return severity === undefined ? problems.length : problems.filter((record) => record.severity === severity).length;
+}
+
+// src/services/settings/write-queue.ts
+function createWriteQueue(opts) {
+  const schedule = opts.schedule ?? queueMicrotask;
+  let pending = null;
+  let tail = Promise.resolve();
+  let idle = Promise.resolve();
+  function flush() {
+    const patch = pending;
+    pending = null;
+    if (!patch) {
+      return tail;
+    }
+    tail = tail.then(() => opts.send(patch)).catch((error) => {
+      opts.onError?.(error, patch);
+    });
+    return tail;
+  }
+  return {
+    enqueue(patch) {
+      if (pending) {
+        Object.assign(pending, patch);
+        return;
+      }
+      pending = { ...patch };
+      idle = new Promise((resolve) => {
+        schedule(() => {
+          flush().then(resolve);
+        });
+      });
+    },
+    settled() {
+      return idle;
+    }
+  };
+}
+
+// src/services/settings/kernel.ts
+var values = new Map;
+function writeCache(key, value) {
+  try {
+    if (value === null) {
+      globalThis.localStorage?.removeItem(key);
+    } else {
+      globalThis.localStorage?.setItem(key, value);
+    }
+  } catch {}
+}
+try {
+  for (const definition of ALL_SETTINGS) {
+    const cached = globalThis.localStorage?.getItem(definition.key);
+    if (cached !== null && cached !== undefined) {
+      values.set(definition.key, cached);
+    }
+  }
+} catch {}
+function readStoredSetting(definition) {
+  return values.get(definition.key) ?? "";
+}
+function hasSetting(definition) {
+  return (values.get(definition.key) ?? "") !== "";
+}
+var listeners = new Set;
+function onSettingsChanged(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function announce2(keys) {
+  for (const listener of listeners) {
+    listener(keys);
+  }
+}
+var queue = createWriteQueue({
+  onError(error) {
+    notify("error", "Your settings could not be saved.", {
+      detail: error instanceof Error ? error.message : String(error),
+      key: "settings-write",
+      source: "Settings"
+    });
+  },
+  async send(patch) {
+    if (!hasPlatform()) {
+      return;
+    }
+    const platform = getPlatform();
+    if (!platform.patchSettings) {
+      return;
+    }
+    const set = {};
+    const remove2 = [];
+    for (const [key, value] of Object.entries(patch)) {
+      if (value) {
+        set[key] = value;
+      } else {
+        remove2.push(key);
+      }
+    }
+    await platform.patchSettings({ remove: remove2, set });
+  }
+});
+function settingsSettled() {
+  return queue.settled();
+}
+function apply2(patch) {
+  const moved = [];
+  for (const [key, next] of Object.entries(patch)) {
+    const before = values.get(key) ?? null;
+    if (before === next) {
+      continue;
+    }
+    if (next === null) {
+      values.delete(key);
+    } else {
+      values.set(key, next);
+    }
+    writeCache(key, next);
+    moved.push(key);
+  }
+  return moved;
+}
+function setSetting(definition, value) {
+  const next = definition.normalize ? definition.normalize(value) : value;
+  const moved = apply2({ [definition.key]: next });
+  if (moved.length > 0) {
+    queue.enqueue({ [definition.key]: next });
+    announce2(moved);
+  }
+}
+function setSettings(entries) {
+  const patch = {};
+  for (const [definition, value] of entries) {
+    patch[definition.key] = definition.normalize ? definition.normalize(value) : value;
+  }
+  const moved = apply2(patch);
+  if (moved.length > 0) {
+    queue.enqueue(patch);
+    announce2(moved);
+  }
+}
+function clearSettings(definitions) {
+  const patch = {};
+  for (const definition of definitions) {
+    patch[definition.key] = null;
+  }
+  const moved = apply2(patch);
+  if (moved.length > 0) {
+    queue.enqueue(patch);
+    announce2(moved);
+  }
+}
+async function hydrateSettings() {
+  if (!hasPlatform()) {
+    return;
+  }
+  const platform = getPlatform();
+  if (!platform.getSettings) {
+    return;
+  }
+  let stored;
+  try {
+    stored = await platform.getSettings();
+  } catch {
+    return;
+  }
+  const incoming = {};
+  let needsMigration = false;
+  for (const definition of USER_SETTINGS) {
+    const backendValue = stored[definition.key];
+    if (backendValue) {
+      incoming[definition.key] = backendValue;
+    } else if (values.get(definition.key)) {
+      needsMigration = true;
+    }
+  }
+  const moved = apply2(incoming);
+  if (moved.length > 0) {
+    announce2(moved);
+  }
+  if (needsMigration) {
+    const push = {};
+    for (const definition of USER_SETTINGS) {
+      const value = values.get(definition.key);
+      if (value && !stored[definition.key]) {
+        push[definition.key] = value;
+      }
+    }
+    queue.enqueue(push);
+  }
+}
+function adoptRemoteSettings(stored) {
+  const patch = {};
+  for (const definition of USER_SETTINGS) {
+    patch[definition.key] = stored[definition.key] ?? null;
+  }
+  const moved = apply2(patch);
+  if (moved.length > 0) {
+    announce2(moved);
+  }
+}
+function watchRemoteSettings() {
+  if (!hasPlatform()) {
+    return;
+  }
+  getPlatform().subscribeSettings?.(adoptRemoteSettings);
+}
+
+export { effectScope, onScopeDispose, effect, onEffectCleanup, reactive, toRaw, isRef, ref, shallowRef, computed, SETTINGS, now, pinClock, toasts, problems, notify, dismiss, clearProblems, problemCount, readStoredSetting, hasSetting, onSettingsChanged, settingsSettled, setSetting, setSettings, clearSettings, hydrateSettings, watchRemoteSettings };
+
+//# debugId=E24768F07DA88AB964756E2164756E21
+//# sourceMappingURL=studio-qpfq7xhm.js.map