apps 0.0.1-beta.37 → 0.0.1-beta.39

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();

package/js/{chunk-ENJCQWVF.js → chunk-E4BWL7KQ.js}

@@ -1,14 +1,14 @@
 import {
   ProviderError,
   maxUpstreamMessageLength
-} from "./chunk-BI6R577B.js";
+} from "./chunk-P7MGDPFD.js";
 import {
   AccountId
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   Option_exports,
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/upstream-error.ts
 var ErrorToken = Schema_exports.String.check(Schema_exports.isPattern(/^[A-Za-z0-9._-]{1,128}$/));

package/js/{chunk-CAOHGMNW.js → chunk-F3TBO2U3.js}

@@ -1,34 +1,24 @@
-import {
-  promiseTable
-} from "./chunk-IU7CCCUC.js";
 import {
   declaredOperations,
   fromPromise,
   nativeOperation,
   nativeRouter
-} from "./chunk-7KEKFBV7.js";
+} from "./chunk-7CSHVXVR.js";
 import {
   ScheduleTiming
-} from "./chunk-LQBR7AI7.js";
-import {
-  DatabaseSchema
-} from "./chunk-73AV3JVU.js";
+} from "./chunk-3V575NIW.js";
 import {
   decoderOf,
   isSchema,
-  schemaArgument,
-  storageFieldOf
-} from "./chunk-POOIHRPF.js";
-import {
-  AppStorageUnavailable
-} from "./chunk-Y3XN4X4Q.js";
+  schemaArgument
+} from "./chunk-GHXRRFZA.js";
 import {
   JsonValue
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/contracts/http.ts
 var ResponseStatusError = class extends Schema_exports.TaggedError()(
@@ -147,7 +137,6 @@ var defineApp = (requirements, definition) => {
   const factory = fromPromise(evaluate);
   const native = {
     accounts: requirements.accounts,
-    ...requirements.database === void 0 ? {} : { database: requirements.database },
     evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))
   };
   return {
@@ -157,87 +146,11 @@ var defineApp = (requirements, definition) => {
   };
 };
 
-// src/implementation/storage.ts
-var table = (fields) => tableWithIndexes(fields, []);
-var tableWithIndexes = (fields, indexes) => ({
-  fields,
-  indexes,
-  index: (name, fieldsInIndex) => tableWithIndexes(fields, [...indexes, { name, fields: fieldsInIndex }])
-});
-var serialize = (tables) => {
-  const definitions = Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => [
-      name,
-      {
-        fields: Object.fromEntries(
-          Object.entries(table2.fields).map(([fieldName, schema]) => {
-            const field = storageFieldOf(schema);
-            if (field === void 0) throw new Error("Database columns must use a scalar schema");
-            return [fieldName, field];
-          })
-        ),
-        indexes: table2.indexes
-      }
-    ])
-  );
-  return Schema_exports.decodeUnknownSync(DatabaseSchema)(definitions);
-};
-var authorDatabase = (tables, session, signal, writable) => {
-  return Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => {
-      const api = promiseTable(session, name, signal);
-      const parseFields = (input, partial) => {
-        const values = Schema_exports.decodeUnknownSync(
-          Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
-        )(input);
-        const fields = {};
-        for (const [key, value] of Object.entries(values)) {
-          if (value === void 0) continue;
-          const field = Object.hasOwn(table2.fields, key) ? table2.fields[key] : void 0;
-          if (field === void 0) throw new Error("Unknown database column");
-          const definition = storageFieldOf(field);
-          fields[key] = value === null && definition?.optional ? null : field.parse(value);
-        }
-        if (!partial) {
-          for (const [key, field] of Object.entries(table2.fields))
-            if (!Object.hasOwn(fields, key)) {
-              const value = field.parse(void 0);
-              if (value !== void 0) fields[key] = value;
-            }
-        }
-        return fields;
-      };
-      const read = { get: api.get, withIndex: api.withIndex };
-      return [
-        name,
-        writable ? {
-          ...read,
-          insert: (value) => api.insert(parseFields(value, false)),
-          update: (id, value) => api.update(id, parseFields(value, true)),
-          delete: api.delete
-        } : read
-      ];
-    })
-  );
-};
-var defineDatabase = (tables) => ({
-  schema: serialize(tables),
-  tables
-});
-var unavailableStorage = {
-  read: () => Effect_exports.fail(new AppStorageUnavailable()),
-  mutate: () => Effect_exports.fail(new AppStorageUnavailable())
-};
-
 export {
   ResponseStatusError,
   ResponseDecodeError,
   workflow,
   isApp,
   toEffectApp,
-  defineApp,
-  table,
-  authorDatabase,
-  defineDatabase,
-  unavailableStorage
+  defineApp
 };

package/js/{chunk-POOIHRPF.js → chunk-GHXRRFZA.js}

@@ -1,7 +1,7 @@
 import {
   JsonObject,
   ValidationError
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   Cause_exports,
   Effect_exports,
@@ -10,7 +10,7 @@ import {
   SchemaIssue_exports,
   SchemaParser_exports,
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
@@ -107,9 +107,9 @@ var ignoredKeyword = {
 var initialBaseURI = typeof self !== "undefined" && self.location && self.location.origin !== "null" ? new URL(self.location.origin + self.location.pathname + location.search) : new URL("https://github.com/cfworker");
 function dereference(schema, lookup = /* @__PURE__ */ Object.create(null), baseURI = initialBaseURI, basePointer = "") {
   if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-    const id2 = schema.$id || schema.id;
-    if (id2) {
-      const url = new URL(id2, baseURI.href);
+    const id = schema.$id || schema.id;
+    if (id) {
+      const url = new URL(id, baseURI.href);
       if (url.hash.length > 1) {
         lookup[url.href] = schema;
       } else {
@@ -1069,7 +1069,6 @@ function schemaPattern(pattern) {
 }
 
 // src/implementation/schema.ts
-var StorageField = /* @__PURE__ */ Symbol("apps.StorageField");
 var Decoder = /* @__PURE__ */ Symbol("apps.Schema");
 var decoderOf = (schema) => schema[Decoder];
 var isSchema = (value) => typeof value === "object" && value !== null && Decoder in value;
@@ -1083,33 +1082,18 @@ var schemaArgument = (value, role) => {
 var parse = (decoder, input) => Effect_exports.suspend(() => Schema_exports.decodeUnknownEffect(decoder)(input)).pipe(
   Effect_exports.mapError(() => new ValidationError())
 );
-function wrap(decoder, optionalValue, field) {
+function wrap(decoder, optionalValue) {
   return {
     [Decoder]: decoder,
-    ...field === void 0 ? {} : { [StorageField]: field },
     optionalValue,
     parse: (input) => Effect_exports.runSync(parse(decoder, input)),
-    optional: () => wrap(
-      Schema_exports.optional(decoder),
-      true,
-      field === void 0 ? void 0 : { ...field, optional: true }
-    ),
+    optional: () => wrap(Schema_exports.optional(decoder), true),
     default: (value) => {
       const parsed = Effect_exports.runSync(parse(decoder, value));
       return {
         ...wrap(
           decoder.annotate({ default: parsed }).pipe(Schema_exports.withDecodingDefault(Effect_exports.succeed(parsed))),
-          false,
-          field === void 0 || parsed === void 0 ? void 0 : {
-            ...field,
-            default: Schema_exports.decodeUnknownSync(
-              Schema_exports.Union([
-                Schema_exports.String,
-                Schema_exports.Finite,
-                Schema_exports.Boolean
-              ])
-            )(parsed)
-          }
+          false
         ),
         hasDefault: true,
         inputOptional: optionalValue
@@ -1120,12 +1104,11 @@ function wrap(decoder, optionalValue, field) {
 function string(options = {}) {
   return wrap(
     options.minLength === void 0 ? Schema_exports.String : Schema_exports.String.check(Schema_exports.isMinLength(options.minLength)),
-    false,
-    { kind: "string" }
+    false
   );
 }
-var number = () => wrap(Schema_exports.Finite, false, { kind: "number" });
-var boolean = () => wrap(Schema_exports.Boolean, false, { kind: "boolean" });
+var number = () => wrap(Schema_exports.Finite, false);
+var boolean = () => wrap(Schema_exports.Boolean, false);
 var json = () => wrap(Schema_exports.Json, false);
 var record = (value) => wrap(
   Schema_exports.Record(
@@ -1752,9 +1735,6 @@ var jsonSchema = (input) => {
     false
   );
 };
-var storageFieldOf = (schema) => schema[StorageField];
-var id = (table) => wrap(Schema_exports.NonEmptyString, false, { kind: "id", references: table });
-var userId = () => wrap(Schema_exports.NonEmptyString, false, { kind: "userId" });
 var jsonSchemaDocument = (decoder) => {
   const imported = importedJsonSchema(decoder);
   if (imported !== void 0) return Schema_exports.decodeUnknownEffect(JsonObject)(imported);
@@ -1797,8 +1777,5 @@ export {
   preparedJsonSchemaDecoder,
   jsonSchemaDecoder,
   jsonSchema,
-  storageFieldOf,
-  id,
-  userId,
   jsonSchemaDocument
 };

package/js/{chunk-RSNZDT4L.js → chunk-JTMDWPCH.js}

@@ -1,9 +1,9 @@
 import {
   appSignInCallbackPath
-} from "./chunk-NHCFIWN5.js";
+} from "./chunk-W2NV54JD.js";
 import {
   HttpServerResponse_exports
-} from "./chunk-KOOJUMLR.js";
+} from "./chunk-3MMG2H6M.js";
 
 // src/implementation/ui-auth.ts
 var appPrivateHeaders = {

package/js/{chunk-YW333DH3.js → chunk-KANDIVIH.js}

@@ -1,17 +1,17 @@
 import {
   CacheError
-} from "./chunk-BI6R577B.js";
+} from "./chunk-P7MGDPFD.js";
 import {
   wrap
-} from "./chunk-POOIHRPF.js";
+} from "./chunk-GHXRRFZA.js";
 import {
   JsonObject
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   Duration_exports,
   Effect_exports,
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/catalog-cache.ts
 var catalogScope = (options, credential, invalid) => {

package/js/{chunk-2FWXCU5I.js → chunk-KAQD3DTI.js}

@@ -1,6 +1,6 @@
 import {
   Predicate_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // ../utils/src/recorded-message.ts
 var RecordedMessage = /* @__PURE__ */ Symbol.for("@executor-js/utils/RecordedMessage");