apps 0.0.1-beta.37 → 0.0.1-beta.38

package/js/{chunk-A4O72Z3A.js → chunk-DKUEYTYD.js}

@@ -1,9 +1,3 @@
-import {
-  Reactivity,
-  invalidate,
-  layer,
-  mutation
-} from "./chunk-HDAQBRT5.js";
 import {
   Boolean,
   Cause,
@@ -43,6 +37,7 @@ import {
   constTrue,
   constVoid,
   constant,
+  context,
   contextWith,
   declareConstructor,
   decodeEffect,
@@ -65,6 +60,7 @@ import {
   fail4 as fail3,
   failCause,
   failCause2,
+  failCauseUnsafe,
   filter,
   filter2,
   filterInterruptors,
@@ -75,9 +71,11 @@ import {
   flatMap2,
   flatMapEager,
   flatMapNullishOr,
+  flow,
   forkDetach,
   fromInputUnsafe,
   fromJsonString,
+  fromQueue,
   gen,
   get,
   get3 as get2,
@@ -87,6 +85,7 @@ import {
   getOrNull,
   getOrThrowWith,
   getOrUndefined,
+  getOrUndefined2,
   getStackTraceLimit,
   getSuccess,
   getUnsafe,
@@ -109,6 +108,7 @@ import {
   joinAll,
   lastNonEmpty,
   link,
+  make3 as make,
   makeCompositeAtKey,
   makeMemoMapUnsafe,
   makeUnsafe2 as makeUnsafe,
@@ -124,14 +124,17 @@ import {
   never,
   none,
   offerUnsafe,
+  onExit,
   pipe,
   pipeArguments,
   provide2 as provide,
   provideMerge,
+  provideService,
   remove3 as remove,
   runCallbackWith,
   runForEachArray,
   runForkWith,
+  runIn,
   runSync,
   runSyncWith,
   scope,
@@ -148,6 +151,7 @@ import {
   symbol,
   symbol2,
   sync2 as sync,
+  tap,
   toCodecJson,
   toMillis,
   toPull,
@@ -158,7 +162,7 @@ import {
   void_2,
   whileLoop,
   zipRight
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
@@ -610,27 +614,27 @@ __export(AtomRegistry_exports, {
   batchState: () => batchState,
   getResult: () => getResult,
   isAtomRegistry: () => isAtomRegistry,
-  layer: () => layer2,
+  layer: () => layer,
   layerOptions: () => layerOptions,
-  make: () => make,
+  make: () => make2,
   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 make2 = (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({
+  const registry = make2({
     ...options,
     scheduleTask: options?.scheduleTask
   });
   yield* addFinalizer(scope2, sync(() => registry.dispose()));
   return registry;
 }));
-var layer2 = /* @__PURE__ */ layerOptions();
+var layer = /* @__PURE__ */ layerOptions();
 var toStream = /* @__PURE__ */ dual(2, (self, atom) => callback2((queue) => suspend(() => {
   const fiber = getCurrent();
   const scope2 = getUnsafe(fiber.context, Scope);
@@ -1442,11 +1446,11 @@ __export(Atom_exports, {
   Reset: () => Reset,
   SerializableTypeId: () => SerializableTypeId2,
   ServerValueTypeId: () => ServerValueTypeId,
-  TypeId: () => TypeId3,
+  TypeId: () => TypeId4,
   WritableTypeId: () => WritableTypeId,
   autoDispose: () => autoDispose,
   batch: () => batch2,
-  context: () => context,
+  context: () => context2,
   debounce: () => debounce,
   family: () => family,
   fn: () => fn,
@@ -1460,7 +1464,7 @@ __export(Atom_exports, {
   isWritable: () => isWritable,
   keepAlive: () => keepAlive,
   kvs: () => kvs,
-  make: () => make2,
+  make: () => make4,
   makeRefreshOnSignal: () => makeRefreshOnSignal,
   map: () => map5,
   mapResult: () => mapResult,
@@ -1495,6 +1499,139 @@ __export(Atom_exports, {
   writable: () => writable
 });
 
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/reactivity/Reactivity.js
+var TypeId3 = "~effect/reactivity/Reactivity";
+var Reactivity = /* @__PURE__ */ Service("effect/reactivity/Reactivity");
+var make3 = /* @__PURE__ */ sync(() => {
+  const handlers = /* @__PURE__ */ new Map();
+  const invalidateUnsafe = (keys) => {
+    keysToHashes(keys, (hash2) => {
+      const set4 = handlers.get(hash2);
+      if (set4 === void 0) return;
+      set4.forEach((run) => run());
+    });
+  };
+  const invalidate2 = (keys) => contextWith((services) => {
+    const pending = getOrUndefined2(services, PendingInvalidation);
+    if (pending) {
+      keysToHashes(keys, (hash2) => {
+        pending.add(hash2);
+      });
+    } else {
+      invalidateUnsafe(keys);
+    }
+    return void_2;
+  });
+  const mutation2 = (keys, effect3) => tap(effect3, invalidate2(keys));
+  const registerUnsafe = (keys, handler) => {
+    const resolvedKeys = [];
+    keysToHashes(keys, (hash2) => {
+      resolvedKeys.push(hash2);
+      let set4 = handlers.get(hash2);
+      if (set4 === void 0) {
+        set4 = /* @__PURE__ */ new Set();
+        handlers.set(hash2, set4);
+      }
+      set4.add(handler);
+    });
+    return () => {
+      for (let i = 0; i < resolvedKeys.length; i++) {
+        const set4 = handlers.get(resolvedKeys[i]);
+        if (set4 === void 0) continue;
+        set4.delete(handler);
+        if (set4.size === 0) {
+          handlers.delete(resolvedKeys[i]);
+        }
+      }
+    };
+  };
+  const query = (keys, effect3) => gen(function* () {
+    const services = yield* context();
+    const scope2 = get(services, Scope);
+    const results = yield* make();
+    const runFork = flow(runForkWith(services), runIn(scope2));
+    let running = false;
+    let pending = false;
+    const handleExit = (exit) => {
+      if (exit._tag === "Failure") {
+        failCauseUnsafe(results, exit.cause);
+      } else {
+        offerUnsafe(results, exit.value);
+      }
+      if (pending) {
+        pending = false;
+        runFork(effect3).addObserver(handleExit);
+      } else {
+        running = false;
+      }
+    };
+    function run() {
+      if (running) {
+        pending = true;
+        return;
+      }
+      running = true;
+      runFork(effect3).addObserver(handleExit);
+    }
+    const cancel = registerUnsafe(keys, run);
+    yield* addFinalizer(scope2, sync(cancel));
+    run();
+    return results;
+  });
+  const stream2 = (tables, effect3) => query(tables, effect3).pipe(map2(fromQueue), unwrap);
+  const withBatch = (effect3) => suspend(() => {
+    const pending = /* @__PURE__ */ new Set();
+    return effect3.pipe(provideService(PendingInvalidation, pending), onExit((_) => sync(() => {
+      pending.forEach((hash2) => {
+        const set4 = handlers.get(hash2);
+        if (set4 === void 0) return;
+        set4.forEach((run) => run());
+      });
+    })));
+  });
+  return Reactivity.of({
+    [TypeId3]: TypeId3,
+    mutation: mutation2,
+    query,
+    stream: stream2,
+    invalidateUnsafe,
+    invalidate: invalidate2,
+    registerUnsafe,
+    withBatch
+  });
+});
+var PendingInvalidation = class extends (/* @__PURE__ */ Service()("effect/reactivity/Reactivity/PendingInvalidation")) {
+};
+var mutation = /* @__PURE__ */ dual(2, (effect3, keys) => Reactivity.use((_) => _.mutation(keys, effect3)));
+var invalidate = (keys) => Reactivity.use((r) => r.invalidate(keys));
+var layer2 = /* @__PURE__ */ effect(Reactivity)(make3);
+function stringOrHash(u) {
+  switch (typeof u) {
+    case "string":
+    case "number":
+    case "bigint":
+    case "boolean":
+      return String(u);
+    default:
+      return hash(u);
+  }
+}
+var keysToHashes = (keys, f) => {
+  if (Array.isArray(keys)) {
+    for (let i = 0; i < keys.length; i++) {
+      f(stringOrHash(keys[i]));
+    }
+    return;
+  }
+  for (const key in keys) {
+    f(key);
+    const ids = keys[key];
+    for (let i = 0; i < ids.length; i++) {
+      f(`${key}:${stringOrHash(ids[i])}`);
+    }
+  }
+};
+
 // ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/persistence/KeyValueStore.js
 var ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
 var KeyValueStoreError = class extends (/* @__PURE__ */ TaggedError("KeyValueStoreError")) {
@@ -1539,8 +1676,8 @@ var toSchemaStore = (self, schema) => {
 };
 
 // ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/reactivity/Atom.js
-var TypeId3 = "~effect/reactivity/Atom";
-var isAtom = (u) => hasProperty(u, TypeId3);
+var TypeId4 = "~effect/reactivity/Atom";
+var isAtom = (u) => hasProperty(u, TypeId4);
 var WritableTypeId = "~effect/reactivity/Atom/Writable";
 var setIdleTTL = /* @__PURE__ */ dual(2, (self, durationInput) => {
   const duration = fromInputUnsafe(durationInput);
@@ -1553,7 +1690,7 @@ var setIdleTTL = /* @__PURE__ */ dual(2, (self, durationInput) => {
 });
 var removeTtl = /* @__PURE__ */ setIdleTTL(0);
 var AtomProto = {
-  [TypeId3]: TypeId3,
+  [TypeId4]: TypeId4,
   equals: Object.is,
   ...PipeInspectableProto,
   toJSON() {
@@ -1651,9 +1788,9 @@ var writable = (read, write, refresh2) => {
 function constSetSelf(ctx, value2) {
   ctx.setSelf(value2);
 }
-var make2 = (arg, options) => {
+var make4 = (arg, options) => {
   const readOrAtom = makeRead(arg, options);
-  if (TypeId3 in readOrAtom) {
+  if (TypeId4 in readOrAtom) {
     return readOrAtom;
   }
   return readable(readOrAtom);
@@ -1723,9 +1860,9 @@ function makeEffect(ctx, effect3, initialValue2, services = empty(), uninterrupt
   }
   return waiting(initialValue2);
 }
-function runCallbackSync(services, effect3, onExit, uninterruptible = false) {
+function runCallbackSync(services, effect3, onExit2, uninterruptible = false) {
   if (isExit(effect3)) {
-    onExit(effect3);
+    onExit2(effect3);
     return void 0;
   }
   const runFork = runForkWith(services);
@@ -1733,10 +1870,10 @@ function runCallbackSync(services, effect3, onExit, uninterruptible = false) {
   fiber.currentDispatcher?.flush();
   const result = fiber.pollUnsafe();
   if (result) {
-    onExit(result);
+    onExit2(result);
     return void 0;
   }
-  const remove2 = fiber.addObserver(onExit);
+  const remove2 = fiber.addObserver(onExit2);
   function cancel() {
     remove2();
     if (!uninterruptible) {
@@ -1745,10 +1882,10 @@ function runCallbackSync(services, effect3, onExit, uninterruptible = false) {
   }
   return cancel;
 }
-function context(options) {
-  const memoMap = options?.memoMap ?? removeTtl(make2(() => makeMemoMapUnsafe()));
+function context2(options) {
+  const memoMap = options?.memoMap ?? removeTtl(make4(() => makeMemoMapUnsafe()));
   const resolveMemoMap = (get5) => isAtom(memoMap) ? get5(memoMap) : memoMap;
-  let globalLayer = layer;
+  let globalLayer = layer2;
   function factory(create) {
     const self = Object.create(RuntimeProto);
     self.keepAlive = false;
@@ -1768,9 +1905,9 @@ function context(options) {
   }
   factory.memoMap = memoMap;
   factory.addGlobalLayer = (layer3) => {
-    globalLayer = provideMerge(globalLayer, provide(layer3, layer));
+    globalLayer = provideMerge(globalLayer, provide(layer3, layer2));
   };
-  const reactivityAtom = removeTtl(make2((get5) => contextWith((services) => buildWithMemoMap(layer, resolveMemoMap(get5), get(services, Scope))).pipe(map2(get(Reactivity)))));
+  const reactivityAtom = removeTtl(make4((get5) => contextWith((services) => buildWithMemoMap(layer2, 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, () => {
@@ -1783,7 +1920,7 @@ function context(options) {
   });
   return factory;
 }
-var runtime = /* @__PURE__ */ context();
+var runtime = /* @__PURE__ */ context2();
 var withReactivity = runtime.withReactivity;
 var stream = (get5, stream2, options, services) => {
   const initialValue2 = options?.initialValue !== void 0 ? success(options.initialValue) : initial();