apps 0.0.1-beta.0

package/js/chunk-YDR4CPJA.js

@@ -0,0 +1,2357 @@
+import {
+  Reactivity,
+  invalidate,
+  layer,
+  mutation
+} from "./chunk-D6BKYP2L.js";
+import {
+  Boolean,
+  Cause,
+  Composite,
+  Defect,
+  Int,
+  InvalidType,
+  MixedScheduler,
+  Never,
+  NoSuchElementError,
+  Option,
+  Option_exports,
+  PipeInspectableProto,
+  Pointer,
+  Scheduler,
+  Scope,
+  Service,
+  TaggedError,
+  TaggedStruct,
+  Union,
+  acquireRelease,
+  add,
+  addFinalizer,
+  appendAll,
+  as,
+  asEquivalence,
+  asSome,
+  assignProperty,
+  buildWithMemoMap,
+  callback,
+  callback2,
+  catchCause,
+  changes,
+  changes2,
+  close,
+  combine,
+  constTrue,
+  constVoid,
+  constant,
+  contextWith,
+  declareConstructor,
+  decodeEffect,
+  decodeExit,
+  decodeSync,
+  decodeUnknownEffect,
+  dual,
+  effect,
+  empty,
+  empty2,
+  empty3,
+  empty7 as empty4,
+  encodeEffect,
+  encodeExit,
+  encodeSync,
+  ensuring2 as ensuring,
+  equals,
+  fail2 as fail,
+  fail3 as fail2,
+  fail4 as fail3,
+  failCause,
+  failCause2,
+  filter,
+  filter2,
+  filterInterruptors,
+  findDefect,
+  findError,
+  findErrorOption,
+  flatMap,
+  flatMap2,
+  flatMapEager,
+  flatMapNullishOr,
+  forkDetach,
+  fromInputUnsafe,
+  fromJsonString,
+  gen,
+  get,
+  get2,
+  get5 as get3,
+  getCurrent,
+  getOrElse,
+  getOrNull,
+  getOrThrowWith,
+  getOrUndefined,
+  getStackTraceLimit,
+  getSuccess,
+  getUnsafe,
+  hasInterruptsOnly,
+  hasProperty,
+  hash,
+  identity,
+  interrupt,
+  isDoneCause,
+  isEffect,
+  isExit,
+  isFailure,
+  isFinite,
+  isIterable,
+  isNone,
+  isReadonlyArrayNonEmpty,
+  isSome,
+  isStream,
+  isSubscriptionRef,
+  joinAll,
+  lastNonEmpty,
+  link,
+  makeCompositeAtKey,
+  makeMemoMapUnsafe,
+  makeUnsafe2 as makeUnsafe,
+  map,
+  map3 as map2,
+  mapBothEager,
+  mapEager,
+  mapEffect,
+  mapErrorEager,
+  match,
+  match2,
+  matchCauseEffect,
+  never,
+  none,
+  offerUnsafe,
+  pipe,
+  pipeArguments,
+  provide2 as provide,
+  provideMerge,
+  remove,
+  runCallbackWith,
+  runForEachArray,
+  runForkWith,
+  runSync,
+  runSyncWith,
+  scope,
+  scopedWith,
+  set,
+  set5 as set2,
+  some,
+  squash,
+  string,
+  succeed2 as succeed,
+  succeed4 as succeed2,
+  succeedNone,
+  suspend,
+  symbol,
+  symbol2,
+  sync2 as sync,
+  toCodecJson,
+  toMillis,
+  toPull,
+  toPullScoped,
+  transform,
+  unwrap3 as unwrap,
+  void_,
+  void_2,
+  whileLoop,
+  zipRight
+} from "./chunk-2OTCEKL2.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
+var AsyncResult_exports = {};
+__export(AsyncResult_exports, {
+  Schema: () => Schema,
+  TypeId: () => TypeId,
+  all: () => all,
+  builder: () => builder,
+  cause: () => cause,
+  error: () => error,
+  fail: () => fail4,
+  failWithPrevious: () => failWithPrevious,
+  failure: () => failure,
+  failureWithPrevious: () => failureWithPrevious,
+  flatMap: () => flatMap3,
+  fromExit: () => fromExit,
+  fromExitWithPrevious: () => fromExitWithPrevious,
+  getOrElse: () => getOrElse2,
+  getOrThrow: () => getOrThrow,
+  initial: () => initial,
+  isAsyncResult: () => isAsyncResult,
+  isFailure: () => isFailure2,
+  isInitial: () => isInitial,
+  isInterrupted: () => isInterrupted,
+  isNotInitial: () => isNotInitial,
+  isSuccess: () => isSuccess,
+  isWaiting: () => isWaiting,
+  map: () => map3,
+  match: () => match3,
+  matchWithError: () => matchWithError,
+  matchWithWaiting: () => matchWithWaiting,
+  replacePrevious: () => replacePrevious,
+  success: () => success,
+  toExit: () => toExit,
+  touch: () => touch,
+  value: () => value,
+  waiting: () => waiting,
+  waitingFrom: () => waitingFrom
+});
+var TypeId = "~effect/reactivity/AsyncResult";
+var isAsyncResult = (u) => hasProperty(u, TypeId);
+var ResultProto = {
+  [TypeId]: {
+    E: identity,
+    A: identity
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  [symbol2](that) {
+    if (this._tag !== that._tag || this.waiting !== that.waiting) {
+      return false;
+    }
+    switch (this._tag) {
+      case "Initial":
+        return true;
+      case "Success":
+        return equals(this.value, that.value);
+      case "Failure":
+        return equals(this.cause, that.cause);
+    }
+  },
+  [symbol]() {
+    const tagHash = string(`${this._tag}:${this.waiting}`);
+    if (this._tag === "Initial") {
+      return tagHash;
+    }
+    return combine(tagHash)(this._tag === "Success" ? hash(this.value) : hash(this.cause));
+  }
+};
+var isWaiting = (result) => result.waiting;
+var fromExit = (exit) => exit._tag === "Success" ? success(exit.value) : failure(exit.cause);
+var fromExitWithPrevious = (exit, previous) => exit._tag === "Success" ? success(exit.value) : failureWithPrevious(exit.cause, {
+  previous
+});
+var waitingFrom = (previous) => {
+  if (previous._tag === "None") {
+    return initial(true);
+  }
+  return waiting(previous.value);
+};
+var isInitial = (result) => result._tag === "Initial";
+var isNotInitial = (result) => result._tag !== "Initial";
+var initial = (waiting2 = false) => {
+  const result = Object.create(ResultProto);
+  result._tag = "Initial";
+  result.waiting = waiting2;
+  return result;
+};
+var isSuccess = (result) => result._tag === "Success";
+var success = (value2, options) => {
+  const result = Object.create(ResultProto);
+  result._tag = "Success";
+  result.value = value2;
+  result.waiting = options?.waiting ?? false;
+  result.timestamp = options?.timestamp ?? Date.now();
+  return result;
+};
+var isFailure2 = (result) => result._tag === "Failure";
+var isInterrupted = (result) => result._tag === "Failure" && hasInterruptsOnly(result.cause);
+var failure = (cause2, options) => {
+  const result = Object.create(ResultProto);
+  result._tag = "Failure";
+  result.cause = cause2;
+  result.previousSuccess = options?.previousSuccess ?? none();
+  result.waiting = options?.waiting ?? false;
+  return result;
+};
+var failureWithPrevious = (cause2, options) => failure(cause2, {
+  previousSuccess: flatMap(options.previous, (result) => isSuccess(result) ? some(result) : isFailure2(result) ? result.previousSuccess : none()),
+  waiting: options.waiting
+});
+var fail4 = (error2, options) => failure(fail(error2), options);
+var failWithPrevious = (error2, options) => failureWithPrevious(fail(error2), options);
+var waiting = (self, options) => {
+  if (self.waiting) {
+    return options?.touch ? touch(self) : self;
+  }
+  const result = Object.assign(Object.create(ResultProto), self);
+  result.waiting = true;
+  if (options?.touch && isSuccess(result)) {
+    ;
+    result.timestamp = Date.now();
+  }
+  return result;
+};
+var touch = (result) => {
+  if (isSuccess(result)) {
+    return success(result.value, {
+      waiting: result.waiting
+    });
+  }
+  return result;
+};
+var replacePrevious = (self, previous) => {
+  if (self._tag === "Failure") {
+    return failureWithPrevious(self.cause, {
+      previous,
+      waiting: self.waiting
+    });
+  }
+  return self;
+};
+var value = (self) => {
+  if (self._tag === "Success") {
+    return some(self.value);
+  } else if (self._tag === "Failure") {
+    return map(self.previousSuccess, (s) => s.value);
+  }
+  return none();
+};
+var getOrElse2 = /* @__PURE__ */ dual(2, (self, orElse) => getOrElse(value(self), orElse));
+var getOrThrow = (self) => getOrThrowWith(value(self), () => new NoSuchElementError("AsyncResult.getOrThrow: no value found"));
+var cause = (self) => self._tag === "Failure" ? some(self.cause) : none();
+var error = (self) => self._tag === "Failure" ? findErrorOption(self.cause) : none();
+var toExit = (self) => {
+  switch (self._tag) {
+    case "Success": {
+      return succeed(self.value);
+    }
+    case "Failure": {
+      return failCause(self.cause);
+    }
+    default: {
+      return fail2(new NoSuchElementError());
+    }
+  }
+};
+var map3 = /* @__PURE__ */ dual(2, (self, f) => {
+  switch (self._tag) {
+    case "Initial":
+      return self;
+    case "Failure":
+      return failure(self.cause, {
+        previousSuccess: map(self.previousSuccess, (s) => success(f(s.value), s)),
+        waiting: self.waiting
+      });
+    case "Success":
+      return success(f(self.value), self);
+  }
+});
+var flatMap3 = /* @__PURE__ */ dual(2, (self, f) => {
+  switch (self._tag) {
+    case "Initial":
+      return self;
+    case "Failure":
+      return failure(self.cause, {
+        previousSuccess: flatMap(self.previousSuccess, (s) => {
+          const next = f(s.value, s);
+          return isSuccess(next) ? some(next) : none();
+        }),
+        waiting: self.waiting
+      });
+    case "Success":
+      return f(self.value, self);
+  }
+});
+var match3 = /* @__PURE__ */ dual(2, (self, options) => {
+  switch (self._tag) {
+    case "Initial":
+      return options.onInitial(self);
+    case "Failure":
+      return options.onFailure(self);
+    case "Success":
+      return options.onSuccess(self);
+  }
+});
+var matchWithError = /* @__PURE__ */ dual(2, (self, options) => {
+  switch (self._tag) {
+    case "Initial":
+      return options.onInitial(self);
+    case "Failure": {
+      const result = findError(self.cause);
+      if (isFailure(result)) {
+        return options.onDefect(squash(result.failure), self);
+      }
+      return options.onError(result.success, self);
+    }
+    case "Success":
+      return options.onSuccess(self);
+  }
+});
+var matchWithWaiting = /* @__PURE__ */ dual(2, (self, options) => {
+  if (self.waiting) {
+    return options.onWaiting(self);
+  }
+  switch (self._tag) {
+    case "Initial":
+      return options.onWaiting(self);
+    case "Failure": {
+      const e = findError(self.cause);
+      if (isFailure(e)) {
+        return options.onDefect(squash(e.failure), self);
+      }
+      return options.onError(e.success, self);
+    }
+    case "Success":
+      return options.onSuccess(self);
+  }
+});
+var all = (results) => {
+  const isIter = isIterable(results);
+  const entries = isIter ? Array.from(results, (result, i) => [i, result]) : Object.entries(results);
+  const successes = isIter ? [] : {};
+  let waiting2 = false;
+  for (let i = 0; i < entries.length; i++) {
+    const [key, result] = entries[i];
+    if (!isAsyncResult(result)) {
+      assignProperty(successes, key, result);
+      continue;
+    } else if (!isSuccess(result)) {
+      return result;
+    }
+    assignProperty(successes, key, result.value);
+    if (result.waiting) {
+      waiting2 = true;
+    }
+  }
+  return success(successes, {
+    waiting: waiting2
+  });
+};
+var builder = (self) => new BuilderImpl(self);
+var BuilderImpl = class {
+  constructor(result) {
+    this.result = result;
+  }
+  result;
+  output = /* @__PURE__ */ none();
+  when(refinement, f) {
+    if (isNone(this.output) && refinement(this.result)) {
+      const b = f(this.result);
+      if (isSome(b)) {
+        ;
+        this.output = b;
+      }
+    }
+    return this;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  onWaiting(f) {
+    return this.when((r) => r.waiting, (r) => some(f(r)));
+  }
+  onInitialOrWaiting(f) {
+    return this.when((r) => isInitial(r) || r.waiting, (r) => some(f(r)));
+  }
+  onInitial(f) {
+    return this.when(isInitial, (r) => some(f(r)));
+  }
+  onSuccess(f) {
+    return this.when(isSuccess, (r) => some(f(r.value, r)));
+  }
+  onFailure(f) {
+    return this.when(isFailure2, (r) => some(f(r.cause, r)));
+  }
+  onError(f) {
+    return this.onErrorIf(constTrue, f);
+  }
+  onErrorIf(refinement, f) {
+    return this.when(isFailure2, (result) => findErrorOption(result.cause).pipe(filter(refinement), map((error2) => f(error2, result))));
+  }
+  onErrorTag(tag, f) {
+    return this.onErrorIf((e) => hasProperty(e, "_tag") && (Array.isArray(tag) ? tag.includes(e._tag) : e._tag === tag), f);
+  }
+  onDefect(f) {
+    return this.when(isFailure2, (result) => {
+      const defect = findDefect(result.cause);
+      return isFailure(defect) ? none() : some(f(defect.success, result));
+    });
+  }
+  onInterrupt(f) {
+    return this.when(isFailure2, (result) => {
+      const interruptors = filterInterruptors(result.cause);
+      return isFailure(interruptors) ? none() : some(f(interruptors.success, result));
+    });
+  }
+  orElse(orElse) {
+    return getOrElse(this.output, orElse);
+  }
+  orNull() {
+    return getOrNull(this.output);
+  }
+  render() {
+    if (isSome(this.output)) {
+      return this.output.value;
+    } else if (isFailure2(this.result)) {
+      throw squash(this.result.cause);
+    }
+    return null;
+  }
+  exhaustive() {
+    return this.render();
+  }
+};
+var Schema = (options) => {
+  const success_ = options.success ?? Never;
+  const error2 = options.error ?? Never;
+  const schema = declareConstructor()([success_, Cause(error2, Defect())], ([value2, cause2]) => (input, ast, options2) => {
+    if (!isAsyncResult(input)) {
+      return fail3(new InvalidType(ast, input, options2));
+    }
+    switch (input._tag) {
+      case "Initial":
+        return succeed2(input);
+      case "Success":
+        return mapBothEager(decodeUnknownEffect(value2)(input.value, options2), {
+          onSuccess: (value3) => success(value3, input),
+          onFailure: (issue) => makeCompositeAtKey(ast, "value", issue, input, options2)
+        });
+      case "Failure": {
+        const prevSuccessEffect = input.previousSuccess.pipe(map((ps) => mapBothEager(decodeUnknownEffect(value2)(ps.value, options2), {
+          onSuccess: (value3) => some(success(value3, ps)),
+          onFailure: (issue) => new Composite(ast, [new Pointer(["previousSuccess", "value"], issue)], input, options2)
+        })), getOrElse(() => succeedNone));
+        const causeEffect = mapErrorEager(decodeUnknownEffect(cause2)(input.cause, options2), (issue) => makeCompositeAtKey(ast, "cause", issue, input, options2));
+        return flatMapEager(prevSuccessEffect, (previousSuccess) => mapEager(causeEffect, (cause3) => failure(cause3, {
+          previousSuccess,
+          waiting: input.waiting
+        })));
+      }
+    }
+  }, {
+    expected: "AsyncResult",
+    toCodec([value2, cause2]) {
+      const Success = TaggedStruct("Success", {
+        value: value2,
+        waiting: Boolean,
+        timestamp: Int
+      });
+      return link()(Union([TaggedStruct("Initial", {
+        waiting: Boolean
+      }), Success, TaggedStruct("Failure", {
+        cause: cause2,
+        previousSuccess: Option(Success),
+        waiting: Boolean
+      })]), transform({
+        decode: (encoded) => {
+          switch (encoded._tag) {
+            case "Initial":
+              return initial(encoded.waiting);
+            case "Success":
+              return success(encoded.value, {
+                waiting: encoded.waiting,
+                timestamp: encoded.timestamp
+              });
+            case "Failure": {
+              return failure(encoded.cause, {
+                previousSuccess: map(encoded.previousSuccess, (ps) => success(ps.value, ps)),
+                waiting: encoded.waiting
+              });
+            }
+          }
+        },
+        encode(result) {
+          switch (result._tag) {
+            case "Initial":
+              return {
+                _tag: "Initial",
+                waiting: result.waiting
+              };
+            case "Success":
+              return {
+                _tag: "Success",
+                value: result.value,
+                waiting: result.waiting,
+                timestamp: result.timestamp
+              };
+            case "Failure":
+              return {
+                _tag: "Failure",
+                cause: result.cause,
+                previousSuccess: result.previousSuccess,
+                waiting: result.waiting
+              };
+          }
+        }
+      }));
+    },
+    toEquivalence: asEquivalence,
+    toFormatter: ([value2, cause2]) => (t) => {
+      switch (t._tag) {
+        case "Success":
+          return `AsyncResult.Success(${value2(t.value)}, ${t.waiting}, ${t.timestamp})`;
+        case "Failure":
+          return `AsyncResult.Failure(${cause2(t.cause)}, ${t.waiting})`;
+        case "Initial":
+          return `AsyncResult.Initial(${t.waiting}, ${t.waiting})`;
+      }
+    }
+  });
+  return Object.assign(schema, {
+    success: success_,
+    error: error2
+  });
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
+var AtomRegistry_exports = {};
+__export(AtomRegistry_exports, {
+  AtomRegistry: () => AtomRegistry,
+  BatchPhase: () => BatchPhase,
+  TypeId: () => TypeId2,
+  batch: () => batch,
+  batchState: () => batchState,
+  getResult: () => getResult,
+  isAtomRegistry: () => isAtomRegistry,
+  layer: () => layer2,
+  layerOptions: () => layerOptions,
+  make: () => make,
+  mount: () => mount,
+  toStream: () => toStream,
+  toStreamResult: () => toStreamResult
+});
+var TypeId2 = "~effect/reactivity/AtomRegistry";
+var isAtomRegistry = (u) => hasProperty(u, TypeId2);
+var make = (options) => new RegistryImpl(options?.initialValues, options?.scheduleTask, options?.timeoutResolution, options?.defaultIdleTTL);
+var AtomRegistry = /* @__PURE__ */ Service(TypeId2);
+var layerOptions = (options) => effect(AtomRegistry, gen(function* () {
+  const scope2 = yield* scope;
+  const registry = make({
+    ...options,
+    scheduleTask: options?.scheduleTask
+  });
+  yield* addFinalizer(scope2, sync(() => registry.dispose()));
+  return registry;
+}));
+var layer2 = /* @__PURE__ */ layerOptions();
+var toStream = /* @__PURE__ */ dual(2, (self, atom) => callback2((queue) => suspend(() => {
+  const fiber = getCurrent();
+  const scope2 = getUnsafe(fiber.context, Scope);
+  const cancel = self.subscribe(atom, (value2) => offerUnsafe(queue, value2), {
+    immediate: true
+  });
+  return addFinalizer(scope2, sync(cancel));
+})));
+var toStreamResult = /* @__PURE__ */ dual(2, (self, atom) => toStream(self, atom).pipe(filter2(isNotInitial), mapEffect((result) => result._tag === "Success" ? succeed2(result.value) : failCause2(result.cause)), changes));
+var getResult = /* @__PURE__ */ dual((args) => isAtomRegistry(args[0]), (self, atom, options) => {
+  const suspendOnWaiting = options?.suspendOnWaiting ?? false;
+  return callback((resume) => {
+    const result = self.get(atom);
+    if (result._tag !== "Initial" && !(suspendOnWaiting && result.waiting)) {
+      return resume(toExit(result));
+    }
+    const cancel = self.subscribe(atom, (value2) => {
+      if (value2._tag !== "Initial" && !(suspendOnWaiting && value2.waiting)) {
+        resume(toExit(value2));
+        cancel();
+      }
+    });
+    return sync(cancel);
+  });
+});
+var mount = /* @__PURE__ */ dual(2, (self, atom) => acquireRelease(sync(() => self.mount(atom)), (release) => sync(release)));
+var constImmediate = {
+  immediate: true
+};
+var notifyListener = (listener) => {
+  listener();
+};
+var SerializableTypeId = "~effect-atom/atom/Atom/Serializable";
+var atomKey = (atom) => SerializableTypeId in atom ? atom[SerializableTypeId].key : atom;
+var RegistryImpl = class {
+  [TypeId2];
+  timeoutResolution;
+  defaultIdleTTL;
+  scheduler;
+  schedulerAsync;
+  dispatcher;
+  onNodeAdded;
+  onNodeRemoved;
+  constructor(initialValues, scheduleTask, timeoutResolution, defaultIdleTTL) {
+    this[TypeId2] = TypeId2;
+    this.scheduler = new MixedScheduler("sync", scheduleTask);
+    this.schedulerAsync = new MixedScheduler("async", scheduleTask);
+    this.dispatcher = this.schedulerAsync.makeDispatcher();
+    this.defaultIdleTTL = defaultIdleTTL;
+    if (timeoutResolution === void 0 && defaultIdleTTL !== void 0) {
+      this.timeoutResolution = Math.round(defaultIdleTTL / 2);
+    } else {
+      this.timeoutResolution = timeoutResolution ?? 1e3;
+    }
+    if (initialValues !== void 0) {
+      for (const [atom, value2] of initialValues) {
+        let target = atom;
+        while (target.initialValueTarget) {
+          target = target.initialValueTarget;
+        }
+        this.ensureNode(target).setInitialValue(value2);
+      }
+    }
+  }
+  nodes = /* @__PURE__ */ new Map();
+  preloadedSerializable = /* @__PURE__ */ new Map();
+  timeoutBuckets = /* @__PURE__ */ new Map();
+  nodeTimeoutBucket = /* @__PURE__ */ new Map();
+  disposed = false;
+  getNodes() {
+    return this.nodes;
+  }
+  get(atom) {
+    return this.ensureNode(atom).value();
+  }
+  set(atom, value2) {
+    atom.write(this.ensureNode(atom).writeContext, value2);
+  }
+  setSerializable(key, encoded) {
+    this.preloadedSerializable.set(key, encoded);
+  }
+  modify(atom, f) {
+    const node = this.ensureNode(atom);
+    const result = f(node.value());
+    atom.write(node.writeContext, result[1]);
+    return result[0];
+  }
+  update(atom, f) {
+    const node = this.ensureNode(atom);
+    atom.write(node.writeContext, f(node.value()));
+  }
+  refresh = (atom) => {
+    if (atom.refresh !== void 0) {
+      atom.refresh(this.refresh);
+    } else {
+      this.invalidateAtom(atom);
+    }
+  };
+  subscribe(atom, f, options) {
+    const node = this.ensureNode(atom);
+    if (options?.immediate) {
+      f(node.value());
+    }
+    const remove2 = node.subscribe(function() {
+      f(node._value);
+    });
+    return () => {
+      remove2();
+      if (node.canBeRemoved) {
+        this.scheduleNodeRemoval(node);
+      }
+    };
+  }
+  mount(atom) {
+    return this.subscribe(atom, constVoid, constImmediate);
+  }
+  atomHasTtl(atom) {
+    return !atom.keepAlive && atom.idleTTL !== 0 && (atom.idleTTL !== void 0 || this.defaultIdleTTL !== void 0);
+  }
+  ensureNode(atom) {
+    const key = atomKey(atom);
+    let node = this.nodes.get(key);
+    if (node === void 0) {
+      node = this.createNode(atom);
+      this.nodes.set(key, node);
+      this.onNodeAdded?.(node);
+    } else if (this.atomHasTtl(atom)) {
+      this.removeNodeTimeout(node);
+    }
+    if (typeof key === "string" && this.preloadedSerializable.has(key)) {
+      const encoded = this.preloadedSerializable.get(key);
+      this.preloadedSerializable.delete(key);
+      const decoded = atom[SerializableTypeId].decode(encoded);
+      let target = atom;
+      while (target.initialValueTarget) {
+        target = target.initialValueTarget;
+      }
+      if (target === atom) {
+        node.setValue(decoded);
+      } else {
+        this.ensureNode(target).setInitialValue(decoded);
+      }
+    }
+    return node;
+  }
+  createNode(atom) {
+    if (this.disposed) {
+      throw new Error(`Cannot access Atom ${atom}: registry is disposed`);
+    }
+    if (!atom.keepAlive) {
+      this.scheduleAtomRemoval(atom);
+    }
+    return new NodeImpl(this, atom);
+  }
+  invalidateAtom = (atom) => {
+    this.ensureNode(atom).invalidate();
+  };
+  scheduleAtomRemoval(atom) {
+    this.dispatcher.scheduleTask(() => {
+      const node = this.nodes.get(atomKey(atom));
+      if (node !== void 0 && node.canBeRemoved) {
+        this.removeNode(node);
+      }
+    }, 0);
+  }
+  scheduleNodeRemoval(node) {
+    this.dispatcher.scheduleTask(() => {
+      if (node.canBeRemoved) {
+        this.removeNode(node);
+      }
+    }, 0);
+  }
+  removeNode(node) {
+    if (this.atomHasTtl(node.atom)) {
+      this.setNodeTimeout(node);
+    } else {
+      this.nodes.delete(atomKey(node.atom));
+      node.remove();
+      this.onNodeRemoved?.(node);
+    }
+  }
+  setNodeTimeout(node) {
+    if (this.nodeTimeoutBucket.has(node)) {
+      return;
+    }
+    let idleTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+    if (this.#currentSweepTTL !== null) {
+      idleTTL -= this.#currentSweepTTL;
+      if (idleTTL <= 0) {
+        this.nodes.delete(atomKey(node.atom));
+        node.remove();
+        this.onNodeRemoved?.(node);
+        return;
+      }
+    }
+    const ttl = Math.ceil(idleTTL / this.timeoutResolution) * this.timeoutResolution;
+    const timestamp = Date.now() + ttl;
+    const bucket = timestamp - timestamp % this.timeoutResolution + this.timeoutResolution;
+    let entry = this.timeoutBuckets.get(bucket);
+    if (entry === void 0) {
+      entry = [/* @__PURE__ */ new Set(), setTimeout(() => this.sweepBucket(bucket), bucket - Date.now())];
+      this.timeoutBuckets.set(bucket, entry);
+    }
+    entry[0].add(node);
+    this.nodeTimeoutBucket.set(node, bucket);
+  }
+  removeNodeTimeout(node) {
+    const bucket = this.nodeTimeoutBucket.get(node);
+    if (bucket === void 0) return;
+    this.nodeTimeoutBucket.delete(node);
+    this.scheduleNodeRemoval(node);
+    const [nodes, handle] = this.timeoutBuckets.get(bucket);
+    nodes.delete(node);
+    if (nodes.size === 0) {
+      clearTimeout(handle);
+      this.timeoutBuckets.delete(bucket);
+    }
+  }
+  #currentSweepTTL = null;
+  sweepBucket(bucket) {
+    const nodes = this.timeoutBuckets.get(bucket)[0];
+    this.timeoutBuckets.delete(bucket);
+    nodes.forEach((node) => {
+      this.nodeTimeoutBucket.delete(node);
+      if (!node.canBeRemoved) return;
+      this.nodes.delete(atomKey(node.atom));
+      this.onNodeRemoved?.(node);
+      this.#currentSweepTTL = node.atom.idleTTL ?? this.defaultIdleTTL;
+      node.remove();
+      this.#currentSweepTTL = null;
+    });
+  }
+  reset() {
+    this.timeoutBuckets.forEach(([, handle]) => clearTimeout(handle));
+    this.timeoutBuckets.clear();
+    this.nodeTimeoutBucket.clear();
+    this.nodes.forEach((node) => {
+      node.remove();
+      this.onNodeRemoved?.(node);
+    });
+    this.nodes.clear();
+  }
+  dispose() {
+    this.disposed = true;
+    this.reset();
+  }
+};
+var NodeFlags = {
+  alive: 1,
+  // 1 << 0
+  initialized: 2,
+  // 1 << 1,
+  waitingForValue: 4
+  // 1 << 2
+};
+var NodeState = {
+  uninitialized: NodeFlags.alive | NodeFlags.waitingForValue,
+  stale: NodeFlags.alive | NodeFlags.initialized | NodeFlags.waitingForValue,
+  valid: NodeFlags.alive | NodeFlags.initialized,
+  removed: 0
+};
+var NodeImpl = class {
+  constructor(registry, atom) {
+    this.registry = registry;
+    this.atom = atom;
+    this.writeContext = new WriteContextImpl(registry, this);
+  }
+  registry;
+  atom;
+  state = NodeState.uninitialized;
+  lifetime;
+  writeContext;
+  preserveInitialValueOnBuild = false;
+  parents = /* @__PURE__ */ new Set();
+  previousParents;
+  children = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  skipInvalidation = false;
+  building = false;
+  invalidatedDuringBuild = false;
+  currentState() {
+    switch (this.state) {
+      case NodeState.uninitialized:
+        return "uninitialized";
+      case NodeState.stale:
+        return "stale";
+      case NodeState.valid:
+        return "valid";
+      default:
+        return "removed";
+    }
+  }
+  get canBeRemoved() {
+    return !this.atom.keepAlive && this.listeners.size === 0 && this.children.size === 0 && this.state !== 0;
+  }
+  _value = void 0;
+  value() {
+    if ((this.state & NodeFlags.waitingForValue) !== 0) {
+      this.lifetime = makeLifetime(this);
+      this.building = true;
+      const value2 = this.atom.read(this.lifetime);
+      this.building = false;
+      if ((this.state & NodeFlags.waitingForValue) !== 0) {
+        if (this.preserveInitialValueOnBuild) {
+          this.preserveInitialValueOnBuild = false;
+          this.state = NodeState.valid;
+        } else {
+          this.setValue(value2);
+        }
+      }
+      if (this.previousParents) {
+        const parents = this.previousParents;
+        this.previousParents = void 0;
+        for (const parent of parents) {
+          parent.removeChild(this);
+          if (parent.canBeRemoved) {
+            this.registry.scheduleNodeRemoval(parent);
+          }
+        }
+      }
+    }
+    return this._value;
+  }
+  valueOption() {
+    if ((this.state & NodeFlags.initialized) === 0) {
+      return none();
+    }
+    return some(this._value);
+  }
+  setInitialValue(value2) {
+    if ((this.state & NodeFlags.initialized) === 0) {
+      this.preserveInitialValueOnBuild = true;
+      this.state = NodeState.stale;
+      this._value = value2;
+      if (batchState.phase === BatchPhase.collect) {
+        batchState.notify.add(this);
+      } else {
+        this.notify();
+      }
+      return;
+    }
+    this.setValue(value2);
+  }
+  setValue(value2) {
+    if ((this.state & NodeFlags.initialized) === 0) {
+      this.state = NodeState.valid;
+      this._value = value2;
+      if (batchState.phase === BatchPhase.collect) {
+        batchState.notify.add(this);
+      } else {
+        this.notify();
+      }
+      return;
+    }
+    this.state = NodeState.valid;
+    if (this.atom.equals(this._value, value2)) {
+      return;
+    }
+    this._value = value2;
+    if (this.skipInvalidation) {
+      this.skipInvalidation = false;
+    } else {
+      this.invalidateChildren();
+    }
+    if (this.listeners.size > 0) {
+      if (batchState.phase === BatchPhase.collect) {
+        batchState.notify.add(this);
+      } else {
+        this.notify();
+      }
+    }
+  }
+  addParent(parent) {
+    this.parents.add(parent);
+    if (this.previousParents !== void 0) {
+      this.previousParents.delete(parent);
+      if (this.previousParents.size === 0) {
+        this.previousParents = void 0;
+      }
+    }
+    if (!parent.children.has(this)) {
+      parent.children.add(this);
+      if (parent.skipInvalidation) {
+        parent.skipInvalidation = false;
+      }
+    }
+  }
+  removeChild(child) {
+    this.children.delete(child);
+  }
+  invalidate() {
+    if (this.building && batchState.phase === BatchPhase.collect) {
+      this.invalidatedDuringBuild = true;
+    }
+    if (this.state === NodeState.valid) {
+      this.state = NodeState.stale;
+      this.disposeLifetime();
+    }
+    if (batchState.phase === BatchPhase.collect) {
+      batchState.stale.push(this);
+    } else if (this.atom.lazy && this.listeners.size === 0 && !childrenAreActive(this.children)) {
+      this.invalidateChildren();
+      this.skipInvalidation = true;
+    } else {
+      this.value();
+    }
+  }
+  invalidateChildren() {
+    if (this.children.size === 0) {
+      return;
+    }
+    const children = this.children;
+    this.children = /* @__PURE__ */ new Set();
+    for (const child of children) {
+      child.invalidate();
+    }
+  }
+  notify() {
+    this.listeners.forEach(notifyListener);
+    if (batchState.phase === BatchPhase.commit) {
+      batchState.notify.delete(this);
+    }
+  }
+  disposeLifetime() {
+    if (this.lifetime !== void 0) {
+      this.lifetime.dispose();
+      this.lifetime = void 0;
+    }
+    if (this.parents.size !== 0) {
+      this.previousParents = this.parents;
+      this.parents = /* @__PURE__ */ new Set();
+    }
+  }
+  remove() {
+    this.state = NodeState.removed;
+    this.listeners.clear();
+    if (this.lifetime !== void 0) {
+      this.disposeLifetime();
+    }
+    if (this.previousParents === void 0) {
+      return;
+    }
+    const parents = this.previousParents;
+    this.previousParents = void 0;
+    for (const parent of parents) {
+      parent.removeChild(this);
+      if (parent.canBeRemoved) {
+        this.registry.removeNode(parent);
+      }
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+};
+function childrenAreActive(children) {
+  if (children.size === 0) {
+    return false;
+  }
+  let current = children;
+  let stack;
+  let stackIndex = 0;
+  while (current !== void 0) {
+    for (const child of current) {
+      if (!child.atom.lazy || child.listeners.size > 0) {
+        return true;
+      } else if (child.children.size > 0) {
+        if (stack === void 0) {
+          stack = [child.children];
+        } else {
+          stack.push(child.children);
+        }
+      }
+    }
+    current = stack?.[stackIndex++];
+  }
+  return false;
+}
+var LifetimeProto = {
+  get registry() {
+    return this.node.registry;
+  },
+  addFinalizer(f) {
+    if (this.disposed) return f();
+    this.finalizers ??= [];
+    this.finalizers.push(f);
+  },
+  get(atom) {
+    if (this.disposed) {
+      return this.node.registry.get(atom);
+    }
+    const parent = this.node.registry.ensureNode(atom);
+    const value2 = parent.value();
+    this.node.addParent(parent);
+    return value2;
+  },
+  result(atom, options) {
+    if (this.disposed || this.isFn) {
+      return this.resultOnce(atom, options);
+    }
+    const result = this.get(atom);
+    if (options?.suspendOnWaiting && result.waiting) {
+      return never;
+    }
+    switch (result._tag) {
+      case "Initial": {
+        return never;
+      }
+      case "Failure": {
+        return failCause(result.cause);
+      }
+      case "Success": {
+        return succeed2(result.value);
+      }
+    }
+  },
+  resultOnce(atom, options) {
+    return callback((resume) => {
+      const result = this.once(atom);
+      if (result._tag !== "Initial" && !(options?.suspendOnWaiting && result.waiting)) {
+        return resume(toExit(result));
+      }
+      const cancel = this.node.registry.subscribe(atom, (result2) => {
+        if (result2._tag === "Initial" || options?.suspendOnWaiting && result2.waiting) return;
+        cancel();
+        resume(toExit(result2));
+      }, {
+        immediate: false
+      });
+      return sync(cancel);
+    });
+  },
+  setResult(atom, value2) {
+    if (this.disposed) return never;
+    this.node.registry.set(atom, value2);
+    return this.resultOnce(atom, {
+      suspendOnWaiting: true
+    });
+  },
+  some(atom) {
+    if (this.disposed || this.isFn) {
+      return this.someOnce(atom);
+    }
+    const result = this.get(atom);
+    return result._tag === "None" ? never : succeed2(result.value);
+  },
+  someOnce(atom) {
+    return callback((resume) => {
+      const result = this.once(atom);
+      if (isSome(result)) {
+        return resume(succeed2(result.value));
+      }
+      const cancel = this.node.registry.subscribe(atom, (result2) => {
+        if (isNone(result2)) return;
+        cancel();
+        resume(succeed2(result2.value));
+      }, {
+        immediate: false
+      });
+      return sync(cancel);
+    });
+  },
+  once(atom) {
+    return this.node.registry.get(atom);
+  },
+  self() {
+    if (this.disposed) return none();
+    return this.node.valueOption();
+  },
+  refresh(atom) {
+    if (this.disposed) return;
+    this.node.registry.refresh(atom);
+  },
+  refreshSelf() {
+    if (this.disposed) return;
+    this.node.invalidate();
+  },
+  mount(atom) {
+    if (this.disposed) return;
+    this.addFinalizer(this.node.registry.mount(atom));
+  },
+  subscribe(atom, f, options) {
+    if (this.disposed) return;
+    this.addFinalizer(this.node.registry.subscribe(atom, f, options));
+  },
+  setSelf(a) {
+    if (this.disposed) return;
+    this.node.setValue(a);
+  },
+  set(atom, value2) {
+    if (this.disposed) return;
+    this.node.registry.set(atom, value2);
+  },
+  stream(atom, options) {
+    if (this.disposed) return empty4;
+    return callback2((queue) => sync(() => {
+      this.subscribe(atom, (value2) => offerUnsafe(queue, value2), {
+        immediate: !options?.withoutInitialValue
+      });
+    }));
+  },
+  streamResult(atom, options) {
+    return this.stream(atom, options).pipe(filter2(isNotInitial), mapEffect((result) => result._tag === "Success" ? succeed2(result.value) : failCause2(result.cause)));
+  },
+  dispose() {
+    this.disposed = true;
+    if (this.finalizers === void 0) {
+      return;
+    }
+    const finalizers = this.finalizers;
+    this.finalizers = void 0;
+    for (let i = finalizers.length - 1; i >= 0; i--) {
+      finalizers[i]();
+    }
+  }
+};
+var makeLifetime = (node) => {
+  function get5(atom) {
+    if (get5.disposed) {
+      return node.registry.get(atom);
+    } else if (get5.isFn) {
+      return node.registry.get(atom);
+    }
+    const parent = node.registry.ensureNode(atom);
+    const value2 = parent.value();
+    node.addParent(parent);
+    return value2;
+  }
+  Object.setPrototypeOf(get5, LifetimeProto);
+  get5.isFn = false;
+  get5.disposed = false;
+  get5.finalizers = void 0;
+  get5.node = node;
+  return get5;
+};
+var WriteContextImpl = class {
+  constructor(registry, node) {
+    this.registry = registry;
+    this.node = node;
+  }
+  registry;
+  node;
+  get(atom) {
+    return this.registry.get(atom);
+  }
+  set(atom, value2) {
+    return this.registry.set(atom, value2);
+  }
+  setSelf(value2) {
+    return this.node.setValue(value2);
+  }
+  refreshSelf() {
+    return this.node.invalidate();
+  }
+};
+var BatchPhase = {
+  disabled: 0,
+  collect: 1,
+  commit: 2
+};
+var batchState = {
+  phase: BatchPhase.disabled,
+  depth: 0,
+  stale: [],
+  notify: /* @__PURE__ */ new Set()
+};
+function batch(f) {
+  batchState.phase = BatchPhase.collect;
+  batchState.depth++;
+  try {
+    f();
+    if (batchState.depth === 1) {
+      for (let i = 0; i < batchState.stale.length; i++) {
+        batchRebuildNode(batchState.stale[i]);
+      }
+      batchState.phase = BatchPhase.commit;
+      for (const node of batchState.notify) {
+        node.notify();
+      }
+      batchState.notify.clear();
+    }
+  } finally {
+    batchState.depth--;
+    if (batchState.depth === 0) {
+      batchState.phase = BatchPhase.disabled;
+      batchState.stale = [];
+    }
+  }
+}
+function batchRebuildNode(node) {
+  if (node.state === NodeState.valid) {
+    if (!node.invalidatedDuringBuild) {
+      return;
+    }
+    node.invalidatedDuringBuild = false;
+    node.state = NodeState.stale;
+    node.disposeLifetime();
+  }
+  for (const parent of node.parents) {
+    if (parent.state !== NodeState.valid) {
+      batchRebuildNode(parent);
+    }
+  }
+  if (node.state !== NodeState.valid) {
+    node.value();
+  }
+}
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+var Atom_exports = {};
+__export(Atom_exports, {
+  Interrupt: () => Interrupt,
+  Reset: () => Reset,
+  SerializableTypeId: () => SerializableTypeId2,
+  ServerValueTypeId: () => ServerValueTypeId,
+  TypeId: () => TypeId3,
+  WritableTypeId: () => WritableTypeId,
+  autoDispose: () => autoDispose,
+  batch: () => batch2,
+  context: () => context,
+  debounce: () => debounce,
+  family: () => family,
+  fn: () => fn,
+  fnSync: () => fnSync,
+  get: () => get4,
+  getResult: () => getResult2,
+  getServerValue: () => getServerValue,
+  initialValue: () => initialValue,
+  isAtom: () => isAtom,
+  isSerializable: () => isSerializable,
+  isWritable: () => isWritable,
+  keepAlive: () => keepAlive,
+  kvs: () => kvs,
+  make: () => make2,
+  makeRefreshOnSignal: () => makeRefreshOnSignal,
+  map: () => map5,
+  mapResult: () => mapResult,
+  modify: () => modify,
+  mount: () => mount2,
+  optimistic: () => optimistic,
+  optimisticFn: () => optimisticFn,
+  pull: () => pull,
+  readable: () => readable,
+  refresh: () => refresh,
+  refreshOnWindowFocus: () => refreshOnWindowFocus,
+  runtime: () => runtime,
+  searchParam: () => searchParam,
+  serializable: () => serializable,
+  set: () => set3,
+  setIdleTTL: () => setIdleTTL,
+  setLazy: () => setLazy,
+  subscriptionRef: () => subscriptionRef,
+  swr: () => swr,
+  toStream: () => toStream2,
+  toStreamResult: () => toStreamResult2,
+  transform: () => transform2,
+  update: () => update,
+  windowFocusSignal: () => windowFocusSignal,
+  withEquality: () => withEquality,
+  withFallback: () => withFallback,
+  withLabel: () => withLabel,
+  withReactivity: () => withReactivity,
+  withRefresh: () => withRefresh,
+  withServerValue: () => withServerValue,
+  withServerValueInitial: () => withServerValueInitial,
+  writable: () => writable
+});
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
+var ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
+var KeyValueStoreError = class extends (/* @__PURE__ */ TaggedError("KeyValueStoreError")) {
+  /**
+   * Marks this value as a key-value store error for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ErrorTypeId] = ErrorTypeId;
+};
+var KeyValueStore = /* @__PURE__ */ Service("effect/persistence/KeyValueStore");
+var SchemaStoreTypeId = "~effect/persistence/KeyValueStore/SchemaStore";
+var toSchemaStore = (self, schema) => {
+  const serializer = toCodecJson(schema);
+  const jsonSchema = fromJsonString(serializer);
+  const decode = decodeEffect(jsonSchema);
+  const encode = encodeEffect(jsonSchema);
+  const get5 = (key) => flatMap2(self.get(key), match2({
+    onUndefined: () => succeedNone,
+    onDefined: (value2) => asSome(decode(value2))
+  }));
+  const set4 = (key, value2) => flatMap2(encode(value2), (json) => self.set(key, json));
+  const modify2 = (key, f) => flatMap2(get5(key), (o) => {
+    if (isNone(o)) {
+      return succeedNone;
+    }
+    const newValue = f(o.value);
+    return as(set4(key, newValue), some(newValue));
+  });
+  return {
+    [SchemaStoreTypeId]: SchemaStoreTypeId,
+    get: get5,
+    set: set4,
+    modify: modify2,
+    remove: self.remove,
+    clear: self.clear,
+    size: self.size,
+    has: self.has,
+    isEmpty: self.isEmpty
+  };
+};
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+var TypeId3 = "~effect/reactivity/Atom";
+var isAtom = (u) => hasProperty(u, TypeId3);
+var WritableTypeId = "~effect/reactivity/Atom/Writable";
+var setIdleTTL = /* @__PURE__ */ dual(2, (self, durationInput) => {
+  const duration = fromInputUnsafe(durationInput);
+  const isFinite2 = isFinite(duration);
+  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
+    ...self,
+    keepAlive: !isFinite2,
+    idleTTL: isFinite2 ? toMillis(duration) : void 0
+  });
+});
+var removeTtl = /* @__PURE__ */ setIdleTTL(0);
+var AtomProto = {
+  [TypeId3]: TypeId3,
+  equals: Object.is,
+  ...PipeInspectableProto,
+  toJSON() {
+    return {
+      _id: "Atom",
+      keepAlive: this.keepAlive,
+      lazy: this.lazy,
+      label: this.label
+    };
+  }
+};
+var RuntimeProto = {
+  ...AtomProto,
+  atom(arg, options) {
+    const read = makeRead(arg, options);
+    return readable((get5) => {
+      const previous = get5.self();
+      const runtimeResult = get5(this);
+      if (runtimeResult._tag !== "Success") {
+        return replacePrevious(runtimeResult, previous);
+      }
+      return read(get5, runtimeResult.value);
+    });
+  },
+  fn(arg, options) {
+    if (arguments.length === 0) {
+      return (arg2, options2) => makeFnRuntime(this, arg2, options2);
+    }
+    return makeFnRuntime(this, arg, options);
+  },
+  pull(arg, options) {
+    const pullSignal = removeTtl(state(0));
+    const pullAtom = readable((get5) => {
+      const previous = get5.self();
+      const runtimeResult = get5(this);
+      if (runtimeResult._tag !== "Success") {
+        return replacePrevious(runtimeResult, previous);
+      }
+      return makeEffect(get5, makeStreamPullEffect(get5, pullSignal, arg, options), initial(true), runtimeResult.value);
+    });
+    return makeStreamPull(pullSignal, pullAtom);
+  },
+  subscriptionRef(ref) {
+    return makeSubRef(removeTtl(readable((get5) => {
+      const previous = get5.self();
+      const runtimeResult = get5(this);
+      if (runtimeResult._tag !== "Success") {
+        return replacePrevious(runtimeResult, previous);
+      }
+      const value2 = typeof ref === "function" ? ref(get5) : ref;
+      return isSubscriptionRef(value2) ? value2 : makeEffect(get5, value2, initial(true), runtimeResult.value);
+    })), (get5, ref2) => {
+      const runtime2 = getOrThrow(get5(this));
+      return readSubscriptionRef(get5, ref2, runtime2);
+    });
+  }
+};
+var makeFnRuntime = (self, arg, options) => {
+  const [read, write, argAtom] = makeResultFn(options?.reactivityKeys ? (a, get5) => {
+    const effect3 = arg(a, get5);
+    return isEffect(effect3) ? mutation(effect3, options.reactivityKeys) : ensuring(effect3, invalidate(options.reactivityKeys));
+  } : arg, options);
+  return writable((get5) => {
+    get5.get(argAtom);
+    const previous = get5.self();
+    const runtimeResult = get5.get(self);
+    if (runtimeResult._tag !== "Success") {
+      return replacePrevious(runtimeResult, previous);
+    }
+    return read(get5, runtimeResult.value);
+  }, write);
+};
+var WritableProto = {
+  ...AtomProto,
+  [WritableTypeId]: WritableTypeId
+};
+var isWritable = (atom) => WritableTypeId in atom;
+var readable = (read, refresh2) => {
+  const self = Object.create(AtomProto);
+  self.keepAlive = false;
+  self.lazy = true;
+  self.read = read;
+  self.refresh = refresh2;
+  return self;
+};
+var writable = (read, write, refresh2) => {
+  const self = Object.create(WritableProto);
+  self.keepAlive = false;
+  self.lazy = true;
+  self.read = read;
+  self.write = write;
+  self.refresh = refresh2;
+  return self;
+};
+function constSetSelf(ctx, value2) {
+  ctx.setSelf(value2);
+}
+var make2 = (arg, options) => {
+  const readOrAtom = makeRead(arg, options);
+  if (TypeId3 in readOrAtom) {
+    return readOrAtom;
+  }
+  return readable(readOrAtom);
+};
+var makeRead = (arg, options) => {
+  if (typeof arg === "function" && !isEffect(arg) && !isStream(arg)) {
+    const create = arg;
+    return function(get5, providedServices) {
+      const value2 = create(get5);
+      switch (typeof value2) {
+        case "function":
+        case "object": {
+          if (value2 === null) return value2;
+          else if (EffectTypeId in value2) {
+            return effect2(get5, value2, options, providedServices);
+          } else if (StreamTypeId in value2) {
+            return stream(get5, value2, options, providedServices);
+          }
+          return value2;
+        }
+        default:
+          return value2;
+      }
+    };
+  } else if (isEffect(arg)) {
+    return function(get5, providedServices) {
+      return effect2(get5, arg, options, providedServices);
+    };
+  } else if (isStream(arg)) {
+    return function(get5, providedServices) {
+      return stream(get5, arg, options, providedServices);
+    };
+  }
+  return state(arg);
+};
+var EffectTypeId = "~effect/Effect";
+var StreamTypeId = "~effect/Stream";
+var state = (initialValue2) => writable(function(_get) {
+  return initialValue2;
+}, constSetSelf);
+var effect2 = (get5, effect3, options, services) => {
+  const initialValue2 = options?.initialValue !== void 0 ? success(options.initialValue) : initial();
+  return makeEffect(get5, effect3, initialValue2, services, options?.uninterruptible);
+};
+function makeEffect(ctx, effect3, initialValue2, services = empty2(), uninterruptible = false) {
+  const previous = ctx.self();
+  const scope2 = makeUnsafe();
+  ctx.addFinalizer(() => {
+    runForkWith(services)(close(scope2, void_));
+  });
+  let syncResult;
+  let isAsync = false;
+  const cancel = runCallbackSync(services.pipe(add(Scope, scope2), add(AtomRegistry, ctx.registry), add(Scheduler, ctx.registry.scheduler)), effect3, function(exit) {
+    syncResult = fromExitWithPrevious(exit, previous);
+    if (isAsync) {
+      ctx.setSelf(syncResult);
+    }
+  }, uninterruptible);
+  isAsync = true;
+  if (cancel !== void 0) {
+    ctx.addFinalizer(cancel);
+  }
+  if (syncResult !== void 0) {
+    return syncResult;
+  } else if (previous._tag === "Some") {
+    return waitingFrom(previous);
+  }
+  return waiting(initialValue2);
+}
+function runCallbackSync(services, effect3, onExit, uninterruptible = false) {
+  if (isExit(effect3)) {
+    onExit(effect3);
+    return void 0;
+  }
+  const runFork = runForkWith(services);
+  const fiber = runFork(effect3);
+  fiber.currentDispatcher?.flush();
+  const result = fiber.pollUnsafe();
+  if (result) {
+    onExit(result);
+    return void 0;
+  }
+  const remove2 = fiber.addObserver(onExit);
+  function cancel() {
+    remove2();
+    if (!uninterruptible) {
+      fiber.interruptUnsafe();
+    }
+  }
+  return cancel;
+}
+function context(options) {
+  const memoMap = options?.memoMap ?? removeTtl(make2(() => makeMemoMapUnsafe()));
+  const resolveMemoMap = (get5) => isAtom(memoMap) ? get5(memoMap) : memoMap;
+  let globalLayer = layer;
+  function factory(create) {
+    const self = Object.create(RuntimeProto);
+    self.keepAlive = false;
+    self.lazy = true;
+    self.refresh = void 0;
+    self.factory = factory;
+    const layerAtom = keepAlive(typeof create === "function" ? readable((get5) => provideMerge(create(get5), globalLayer)) : readable(() => provideMerge(create, globalLayer)));
+    self.layer = layerAtom;
+    self.read = function read(get5) {
+      const layer3 = get5(layerAtom);
+      const build = flatMap2(scope, (scope2) => buildWithMemoMap(layer3, resolveMemoMap(get5), scope2));
+      return effect2(get5, build, {
+        uninterruptible: true
+      });
+    };
+    return self;
+  }
+  factory.memoMap = memoMap;
+  factory.addGlobalLayer = (layer3) => {
+    globalLayer = provideMerge(globalLayer, provide(layer3, layer));
+  };
+  const reactivityAtom = removeTtl(make2((get5) => contextWith((services) => buildWithMemoMap(layer, resolveMemoMap(get5), get(services, Scope))).pipe(map2(get(Reactivity)))));
+  factory.withReactivity = (keys) => (atom) => transform2(atom, (get5) => {
+    const reactivity = getOrThrow(get5(reactivityAtom));
+    get5.addFinalizer(reactivity.registerUnsafe(keys, () => {
+      get5.refresh(atom);
+    }));
+    get5.subscribe(atom, (value2) => get5.setSelf(value2));
+    return get5.once(atom);
+  }, {
+    initialValueTarget: atom
+  });
+  return factory;
+}
+var runtime = /* @__PURE__ */ context();
+var withReactivity = runtime.withReactivity;
+var stream = (get5, stream2, options, services) => {
+  const initialValue2 = options?.initialValue !== void 0 ? success(options.initialValue) : initial();
+  return makeStream(get5, stream2, initialValue2, services);
+};
+function makeStream(ctx, stream2, initialValue2, services = empty2()) {
+  const previous = ctx.self();
+  services = add(services, AtomRegistry, ctx.registry);
+  const run = scopedWith((scope2) => flatMap2(toPullScoped(stream2.channel, scope2), (pull2) => whileLoop({
+    while: constTrue,
+    body: () => pull2,
+    step(arr) {
+      ctx.setSelf(success(lastNonEmpty(arr), {
+        waiting: true
+      }));
+    }
+  }))).pipe(catchCause((cause2) => {
+    if (isDoneCause(cause2)) {
+      pipe(ctx.self(), flatMap(value), match({
+        onNone: () => ctx.setSelf(failWithPrevious(new NoSuchElementError(), {
+          previous: ctx.self()
+        })),
+        onSome: (a) => ctx.setSelf(success(a))
+      }));
+    } else {
+      ctx.setSelf(failureWithPrevious(cause2, {
+        previous: ctx.self()
+      }));
+    }
+    return void_2;
+  }));
+  const cancel = runCallbackSync(services.pipe(add(AtomRegistry, ctx.registry), add(Scheduler, ctx.registry.scheduler)), run, constVoid, false);
+  if (cancel !== void 0) {
+    ctx.addFinalizer(cancel);
+  }
+  if (previous._tag === "Some") {
+    return waitingFrom(previous);
+  }
+  return waiting(initialValue2);
+}
+var subscriptionRef = (ref) => makeSubRef(readable((get5) => {
+  const value2 = typeof ref === "function" ? ref(get5) : ref;
+  return isSubscriptionRef(value2) ? value2 : makeEffect(get5, value2, initial(true));
+}), readSubscriptionRef);
+var readSubscriptionRef = (get5, sub, services = empty2()) => {
+  if (isSubscriptionRef(sub)) {
+    get5.addFinalizer(changes2(sub).pipe(runForEachArray((arr) => {
+      for (let i = 0; i < arr.length; i++) {
+        get5.setSelf(arr[i]);
+      }
+      return void_2;
+    }), runCallbackWith(services)));
+    return runSyncWith(services)(get3(sub));
+  } else if (sub._tag !== "Success") {
+    return sub;
+  }
+  return makeStream(get5, changes2(sub.value), initial(true), services);
+};
+var makeSubRef = (refAtom, read) => {
+  function write(ctx, value2) {
+    const ref = ctx.get(refAtom);
+    if (isSubscriptionRef(ref)) {
+      runSync(set2(ref, value2));
+    } else if (isSuccess(ref)) {
+      runSync(set2(ref.value, value2));
+    }
+  }
+  return writable((get5) => {
+    const ref = get5(refAtom);
+    if (isSubscriptionRef(ref)) {
+      return read(get5, ref);
+    } else if (isSuccess(ref)) {
+      return read(get5, ref);
+    }
+    return ref;
+  }, write);
+};
+var fnSync = function(...args) {
+  if (args.length === 0) {
+    return makeFnSync;
+  }
+  return makeFnSync(...args);
+};
+var makeFnSync = (f, options) => {
+  const argAtom = removeTtl(state([0, void 0]));
+  const hasInitialValue = options?.initialValue !== void 0;
+  return writable(function(get5) {
+    ;
+    get5.isFn = true;
+    const [counter, arg] = get5.get(argAtom);
+    if (counter === 0) {
+      return hasInitialValue ? options.initialValue : none();
+    }
+    return hasInitialValue ? f(arg, get5) : some(f(arg, get5));
+  }, function(ctx, arg) {
+    batch2(() => {
+      ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, arg]);
+      ctx.refreshSelf();
+    });
+  });
+};
+var Reset = /* @__PURE__ */ Symbol.for("effect/reactivity/atom/Atom/Reset");
+var Interrupt = /* @__PURE__ */ Symbol.for("effect/reactivity/atom/Atom/Interrupt");
+var fn = function(...args) {
+  if (args.length === 0) {
+    return makeFn;
+  }
+  return makeFn(...args);
+};
+var makeFn = (f, options) => {
+  const [read, write] = makeResultFn(f, options);
+  return writable(read, write);
+};
+function makeResultFn(f, options) {
+  const argAtom = removeTtl(state([0, void 0]));
+  const initialValue2 = options?.initialValue !== void 0 ? success(options.initialValue) : initial();
+  const fibersAtom = options?.concurrent ? removeTtl(readable((get5) => {
+    const fibers = /* @__PURE__ */ new Set();
+    get5.addFinalizer(() => fibers.forEach((f2) => f2.interruptUnsafe()));
+    return fibers;
+  })) : void 0;
+  function read(get5, services) {
+    const fibers = fibersAtom ? get5(fibersAtom) : void 0;
+    get5.isFn = true;
+    const [counter, arg] = get5.get(argAtom);
+    if (counter === 0) {
+      return initialValue2;
+    } else if (arg === Interrupt) {
+      return failureWithPrevious(interrupt(), {
+        previous: get5.self()
+      });
+    }
+    let value2 = f(arg, get5);
+    if (EffectTypeId in value2) {
+      if (fibers) {
+        const eff = value2;
+        value2 = flatMap2(forkDetach(eff, {
+          startImmediately: true
+        }), (fiber) => {
+          fibers.add(fiber);
+          fiber.addObserver(() => fibers.delete(fiber));
+          return map2(joinAll(fibers), (arr) => arr[0]);
+        });
+      }
+      return makeEffect(get5, value2, initialValue2, services, false);
+    }
+    return makeStream(get5, value2, initialValue2, services);
+  }
+  function write(ctx, arg) {
+    batch2(() => {
+      if (arg === Reset) {
+        ctx.set(argAtom, [0, void 0]);
+      } else if (arg === Interrupt) {
+        ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, Interrupt]);
+      } else {
+        ctx.set(argAtom, [ctx.get(argAtom)[0] + 1, arg]);
+      }
+      ctx.refreshSelf();
+    });
+  }
+  return [read, write, argAtom];
+}
+var pull = (create, options) => {
+  const pullSignal = removeTtl(state(0));
+  const pullAtom = readable(makeRead(function(get5) {
+    return makeStreamPullEffect(get5, pullSignal, create, options);
+  }));
+  return makeStreamPull(pullSignal, pullAtom);
+};
+var makeStreamPullEffect = (get5, pullSignal, create, options) => flatMap2(toPull(typeof create === "function" ? create(get5) : create), (pullChunk) => {
+  const fiber = getCurrent();
+  const services = fiber.context;
+  let acc = empty();
+  const pull2 = matchCauseEffect(pullChunk, {
+    onFailure(cause2) {
+      if (isDoneCause(cause2)) {
+        if (!isReadonlyArrayNonEmpty(acc)) {
+          return fail3(new NoSuchElementError(`Atom.pull: no items`));
+        }
+        return succeed2({
+          done: true,
+          items: acc
+        });
+      }
+      return failCause2(cause2);
+    },
+    onSuccess(chunk) {
+      let items;
+      if (options?.disableAccumulation) {
+        items = chunk;
+      } else {
+        items = appendAll(acc, chunk);
+        acc = items;
+      }
+      return succeed2({
+        done: false,
+        items
+      });
+    }
+  });
+  const cancels = /* @__PURE__ */ new Set();
+  get5.addFinalizer(() => {
+    for (const cancel of cancels) cancel();
+  });
+  get5.once(pullSignal);
+  get5.subscribe(pullSignal, () => {
+    get5.setSelf(waitingFrom(get5.self()));
+    let cancel;
+    cancel = runCallbackSync(services, pull2, (exit) => {
+      if (cancel) cancels.delete(cancel);
+      const result = fromExitWithPrevious(exit, get5.self());
+      const pending = cancels.size > 0;
+      get5.setSelf(pending ? waiting(result) : result);
+    });
+    if (cancel) cancels.add(cancel);
+  });
+  return pull2;
+});
+var makeStreamPull = (pullSignal, pullAtom) => writable(pullAtom.read, function(ctx, _) {
+  ctx.set(pullSignal, ctx.get(pullSignal) + 1);
+});
+var family = typeof WeakRef === "undefined" || typeof FinalizationRegistry === "undefined" ? (f) => {
+  const atoms = empty3();
+  return function(arg) {
+    const atomEntry = get2(atoms, arg);
+    if (atomEntry._tag === "Some") {
+      return atomEntry.value;
+    }
+    const newAtom = f(arg);
+    set(atoms, arg, newAtom);
+    return newAtom;
+  };
+} : (f) => {
+  const atoms = empty3();
+  const registry = new FinalizationRegistry((arg) => {
+    remove(atoms, arg);
+  });
+  return function(arg) {
+    const atomEntry = get2(atoms, arg).pipe(flatMapNullishOr((ref) => ref.deref()));
+    if (atomEntry._tag === "Some") {
+      return atomEntry.value;
+    }
+    const newAtom = f(arg);
+    set(atoms, arg, new WeakRef(newAtom));
+    registry.register(newAtom, arg);
+    return newAtom;
+  };
+};
+var withFallback = /* @__PURE__ */ dual(2, (self, fallback) => {
+  function withFallback2(get5) {
+    const result = get5(self);
+    if (result._tag === "Initial") {
+      return waiting(get5(fallback));
+    }
+    return result;
+  }
+  return isWritable(self) ? writable(withFallback2, function(ctx, value2) {
+    ctx.set(self, value2);
+  }, self.refresh ?? function(refresh2) {
+    refresh2(self);
+  }) : readable(withFallback2, self.refresh ?? function(refresh2) {
+    refresh2(self);
+  });
+});
+var keepAlive = (self) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+  ...self,
+  keepAlive: true
+});
+var autoDispose = (self) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+  ...self,
+  keepAlive: false
+});
+var setLazy = /* @__PURE__ */ dual(2, (self, lazy) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+  ...self,
+  lazy
+}));
+var withEquality = /* @__PURE__ */ dual(2, (self, equals2) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+  ...self,
+  equals: equals2
+}));
+var withLabel = /* @__PURE__ */ dual(2, (self, name) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+  ...self,
+  label: [name, getStackTraceLimit() === 0 ? "" : new Error().stack?.split("\n")[5] ?? ""]
+}));
+var initialValue = /* @__PURE__ */ dual(2, (self, initialValue2) => [self, initialValue2]);
+var transform2 = /* @__PURE__ */ dual((args) => isAtom(args[0]), (self, f, options) => {
+  const atom = removeTtl(isWritable(self) ? writable((get5) => f(get5, self), function(ctx, value2) {
+    ctx.set(self, value2);
+  }, self.refresh ?? function(refresh2) {
+    refresh2(self);
+  }) : readable((get5) => f(get5, self), self.refresh ?? function(refresh2) {
+    refresh2(self);
+  }));
+  if (options?.initialValueTarget) {
+    ;
+    atom.initialValueTarget = getInitialValueTarget(options.initialValueTarget);
+  }
+  return atom;
+});
+var getInitialValueTarget = (atom) => {
+  let target = atom;
+  while (target.initialValueTarget) {
+    target = target.initialValueTarget;
+  }
+  return target;
+};
+var map5 = /* @__PURE__ */ dual(2, (self, f) => transform2(self, (get5) => f(get5(self))));
+var mapResult = /* @__PURE__ */ dual(2, (self, f) => map5(self, map3(f)));
+var debounce = /* @__PURE__ */ dual(2, (self, duration) => {
+  const millis = toMillis(fromInputUnsafe(duration));
+  return transform2(self, function(get5) {
+    let timeout;
+    let value2 = get5.once(self);
+    function update2() {
+      timeout = void 0;
+      get5.setSelf(value2);
+    }
+    get5.addFinalizer(function() {
+      if (timeout) clearTimeout(timeout);
+    });
+    get5.subscribe(self, function(val) {
+      value2 = val;
+      if (timeout) clearTimeout(timeout);
+      timeout = setTimeout(update2, millis);
+    });
+    return value2;
+  }, {
+    initialValueTarget: self
+  });
+});
+var withRefresh = /* @__PURE__ */ dual(2, (self, duration) => {
+  const millis = toMillis(fromInputUnsafe(duration));
+  return transform2(self, function(get5) {
+    const handle = setTimeout(() => get5.refresh(self), millis);
+    get5.addFinalizer(() => clearTimeout(handle));
+    return get5(self);
+  }, {
+    initialValueTarget: self
+  });
+});
+var swr = /* @__PURE__ */ dual(2, (self, options) => {
+  const staleTime = toMillis(fromInputUnsafe(options.staleTime));
+  return transform2(self, (get5) => {
+    const current = get5.once(self);
+    get5.subscribe(self, (value2) => {
+      get5.setSelf(value2);
+    });
+    if (options.revalidateOnFocus && options.focusSignal) {
+      get5.once(options.focusSignal);
+      get5.subscribe(options.focusSignal, options.revalidateOnFocus === "always" ? () => get5.refresh(self) : () => {
+        const current2 = get5.once(self);
+        if (shouldRevalidateSWR(current2, staleTime)) {
+          get5.refresh(self);
+        }
+      });
+    }
+    const firstRead = isNone(get5.self());
+    if (firstRead && options.revalidateOnMount === false) {
+      return current;
+    }
+    if (shouldRevalidateSWR(current, staleTime)) {
+      get5.refresh(self);
+    }
+    return current;
+  }, {
+    initialValueTarget: self
+  });
+});
+var swrTimestamp = (result) => {
+  if (result._tag === "Success") {
+    return some(result.timestamp);
+  }
+  if (result._tag === "Failure") {
+    return map(result.previousSuccess, (success2) => success2.timestamp);
+  }
+  return none();
+};
+var isFreshWithin = (timestamp, staleTime, now) => now - timestamp < staleTime;
+var shouldRevalidateSWR = (result, staleTime) => {
+  if (result.waiting) {
+    return false;
+  }
+  const timestamp = getOrUndefined(swrTimestamp(result));
+  if (timestamp === void 0) {
+    return result._tag !== "Initial";
+  }
+  return !isFreshWithin(timestamp, staleTime, Date.now());
+};
+var optimistic = (self) => {
+  let counter = 0;
+  const writeAtom = removeTtl(state([counter, void 0]));
+  return writable((get5) => {
+    let lastValue = get5.once(self);
+    let needsRefresh = false;
+    get5.subscribe(self, (value2) => {
+      lastValue = value2;
+      if (transitions.size > 0) {
+        return;
+      }
+      needsRefresh = false;
+      if (!isAsyncResult(value2)) {
+        return get5.setSelf(value2);
+      }
+      const current = getOrUndefined(get5.self());
+      switch (value2._tag) {
+        case "Initial": {
+          if (isInitial(current)) {
+            get5.setSelf(value2);
+          }
+          return;
+        }
+        case "Success": {
+          if (isSuccess(current)) {
+            if (!value2.waiting && value2.timestamp >= current.timestamp) {
+              get5.setSelf(value2);
+            }
+          } else {
+            get5.setSelf(value2);
+          }
+          return;
+        }
+        case "Failure": {
+          return get5.setSelf(value2);
+        }
+      }
+    });
+    const transitions = /* @__PURE__ */ new Set();
+    const cancels = /* @__PURE__ */ new Set();
+    get5.subscribe(writeAtom, ([, atom]) => {
+      if (transitions.has(atom)) return;
+      transitions.add(atom);
+      let cancel;
+      cancel = get5.registry.subscribe(atom, (result) => {
+        if (isSuccess(result) && result.waiting) {
+          return get5.setSelf(result.value);
+        }
+        transitions.delete(atom);
+        if (cancel) {
+          cancels.delete(cancel);
+          cancel();
+        }
+        if (!needsRefresh && !isFailure2(result)) {
+          needsRefresh = true;
+        }
+        if (transitions.size === 0) {
+          if (needsRefresh) {
+            needsRefresh = false;
+            get5.refresh(self);
+          } else {
+            get5.setSelf(lastValue);
+          }
+        }
+      }, {
+        immediate: true
+      });
+      if (transitions.has(atom)) {
+        cancels.add(cancel);
+      } else {
+        cancel();
+      }
+    });
+    get5.addFinalizer(() => {
+      for (const cancel of cancels) cancel();
+      transitions.clear();
+      cancels.clear();
+    });
+    return lastValue;
+  }, (ctx, atom) => ctx.set(writeAtom, [++counter, atom]), (refresh2) => refresh2(self));
+};
+var optimisticFn = /* @__PURE__ */ dual(2, (self, options) => {
+  const transition = removeTtl(state(initial()));
+  return fn((arg, get5) => {
+    let value2 = options.reducer(get5(self), arg);
+    if (isAsyncResult(value2)) {
+      value2 = waiting(value2, {
+        touch: true
+      });
+    }
+    get5.set(transition, success(value2, {
+      waiting: true
+    }));
+    get5.set(self, transition);
+    const fn2 = typeof options.fn === "function" ? autoDispose(options.fn((value3) => get5.set(transition, success(isAsyncResult(value3) ? waiting(value3) : value3, {
+      waiting: true
+    })))) : options.fn;
+    get5.set(fn2, arg);
+    return callback((resume) => {
+      get5.subscribe(fn2, (result) => {
+        if (result._tag === "Initial" || result.waiting) return;
+        get5.set(transition, map3(result, () => value2));
+        resume(toExit(result));
+      }, {
+        immediate: true
+      });
+    });
+  });
+});
+var batch2 = batch;
+var windowFocusSignal = /* @__PURE__ */ readable((get5) => {
+  let count = 0;
+  function update2() {
+    if (document.visibilityState === "visible") {
+      get5.setSelf(++count);
+    }
+  }
+  window.addEventListener("visibilitychange", update2);
+  get5.addFinalizer(() => {
+    window.removeEventListener("visibilitychange", update2);
+  });
+  return count;
+});
+var makeRefreshOnSignal = (signal) => (self) => transform2(self, (get5) => {
+  get5.once(signal);
+  get5.subscribe(signal, (_) => get5.refresh(self));
+  get5.subscribe(self, (value2) => get5.setSelf(value2));
+  return get5.once(self);
+}, {
+  initialValueTarget: self
+});
+var refreshOnWindowFocus = /* @__PURE__ */ makeRefreshOnSignal(windowFocusSignal);
+var kvs = (options) => {
+  const setAtom = options.runtime.fn((value2) => KeyValueStore.use((store) => toSchemaStore(store, options.schema).set(options.key, value2)));
+  const resultAtom = options.runtime.atom(KeyValueStore.use((store) => toSchemaStore(store, options.schema).get(options.key)));
+  return writable(options.mode === "async" ? (get5) => {
+    get5.mount(setAtom);
+    const mapper = map3(getOrElse(() => {
+      const value2 = options.defaultValue();
+      get5.set(setAtom, value2);
+      return value2;
+    }));
+    get5.subscribe(resultAtom, (result) => get5.setSelf(mapper(result)));
+    return mapper(get5.once(resultAtom));
+  } : (get5) => {
+    get5.mount(setAtom);
+    get5.subscribe(resultAtom, (result) => {
+      if (!isSuccess(result)) return;
+      if (isSome(result.value)) {
+        get5.setSelf(result.value.value);
+      } else {
+        const value2 = getOrElse(get5.self(), options.defaultValue);
+        get5.setSelf(value2);
+        get5.set(setAtom, value2);
+      }
+    }, {
+      immediate: true
+    });
+    return getOrElse(get5.self(), options.defaultValue);
+  }, (ctx, value2) => {
+    ctx.set(setAtom, value2);
+    ctx.setSelf(options.mode === "async" ? success(value2) : value2);
+  });
+};
+var searchParam = (name, options) => {
+  const decode = options?.schema && decodeExit(options.schema);
+  const encode = options?.schema && encodeExit(options.schema);
+  return writable((get5) => {
+    if (typeof window === "undefined") {
+      return decode ? none() : "";
+    }
+    const handleUpdate = () => {
+      if (searchParamState.updating) return;
+      const searchParams = new URLSearchParams(window.location.search);
+      const newValue = searchParams.get(name) || "";
+      if (decode) {
+        get5.setSelf(getSuccess(decode(newValue)));
+      } else if (newValue !== getOrUndefined(get5.self())) {
+        get5.setSelf(newValue);
+      }
+    };
+    window.addEventListener("popstate", handleUpdate);
+    window.addEventListener("pushstate", handleUpdate);
+    get5.addFinalizer(() => {
+      window.removeEventListener("popstate", handleUpdate);
+      window.removeEventListener("pushstate", handleUpdate);
+    });
+    const value2 = new URLSearchParams(window.location.search).get(name) || "";
+    return decode ? getSuccess(decode(value2)) : value2;
+  }, (ctx, value2) => {
+    if (typeof window === "undefined") {
+      ctx.setSelf(value2);
+      return;
+    }
+    if (encode) {
+      const encoded = flatMap(value2, (v) => getSuccess(encode(v)));
+      searchParamState.updates.set(name, getOrElse(encoded, () => ""));
+      value2 = zipRight(encoded, value2);
+    } else {
+      searchParamState.updates.set(name, value2);
+    }
+    ctx.setSelf(value2);
+    if (searchParamState.timeout) {
+      clearTimeout(searchParamState.timeout);
+    }
+    searchParamState.timeout = setTimeout(updateSearchParams, 500);
+  });
+};
+var searchParamState = {
+  timeout: void 0,
+  updates: /* @__PURE__ */ new Map(),
+  updating: false
+};
+function updateSearchParams() {
+  searchParamState.timeout = void 0;
+  searchParamState.updating = true;
+  const searchParams = new URLSearchParams(window.location.search);
+  for (const [key, value2] of searchParamState.updates.entries()) {
+    if (value2.length > 0) {
+      searchParams.set(key, value2);
+    } else {
+      searchParams.delete(key);
+    }
+  }
+  searchParamState.updates.clear();
+  const newUrl = `${window.location.pathname}?${searchParams.toString()}`;
+  window.history.pushState({}, "", newUrl);
+  searchParamState.updating = false;
+}
+var toStream2 = (self) => unwrap(AtomRegistry.use((r) => succeed2(toStream(r, self))));
+var toStreamResult2 = (self) => unwrap(AtomRegistry.use((r) => succeed2(toStreamResult(r, self))));
+var get4 = (self) => AtomRegistry.use((r) => succeed2(r.get(self)));
+var modify = /* @__PURE__ */ dual(2, (self, f) => map2(AtomRegistry, (_) => _.modify(self, f)));
+var set3 = /* @__PURE__ */ dual(2, (self, value2) => map2(AtomRegistry, (_) => _.set(self, value2)));
+var update = /* @__PURE__ */ dual(2, (self, f) => map2(AtomRegistry, (_) => _.update(self, f)));
+var getResult2 = (self, options) => AtomRegistry.use(getResult(self, options));
+var refresh = (self) => map2(AtomRegistry, (_) => _.refresh(self));
+var mount2 = (self) => AtomRegistry.use((r) => mount(r, self));
+var SerializableTypeId2 = "~effect-atom/atom/Atom/Serializable";
+var isSerializable = (self) => SerializableTypeId2 in self;
+var serializable = /* @__PURE__ */ dual(2, (self, options) => {
+  const codecJson = toCodecJson(options.schema);
+  return Object.assign(Object.create(Object.getPrototypeOf(self)), {
+    ...self,
+    label: self.label ?? [options.key, getStackTraceLimit() === 0 ? "" : new Error().stack?.split("\n")[5] ?? ""],
+    [SerializableTypeId2]: {
+      key: options.key,
+      encode: encodeSync(codecJson),
+      decode: decodeSync(codecJson)
+    }
+  });
+});
+var ServerValueTypeId = "~effect-atom/atom/Atom/ServerValue";
+var withServerValue = /* @__PURE__ */ dual(2, (self, read) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
+  ...self,
+  [ServerValueTypeId]: read
+}));
+var withServerValueInitial = (self) => withServerValue(self, constant(initial(true)));
+var getServerValue = /* @__PURE__ */ dual(2, (self, registry) => ServerValueTypeId in self ? self[ServerValueTypeId]((atom) => registry.get(atom)) : registry.get(self));
+
+// src/implementation/query-commit.ts
+var commits = /* @__PURE__ */ new WeakMap();
+var queryResult = (result) => {
+  const visible = AsyncResult_exports.map(result, (observed2) => observed2.value);
+  const observed = AsyncResult_exports.value(result);
+  if (Option_exports.isSome(observed)) commits.set(visible, observed.value.commit);
+  return visible;
+};
+var queryCommitted = (result) => {
+  commits.get(result)?.();
+};
+
+export {
+  AsyncResult_exports,
+  AtomRegistry_exports,
+  Atom_exports,
+  queryResult,
+  queryCommitted
+};