apps 0.0.1-beta.36 → 0.0.1-beta.38

package/js/{chunk-4U2VUDET.js → chunk-5TJA7364.js}

@@ -5,11 +5,11 @@ import {
   SkillDefinitionInvalid,
   SkillFile,
   SkillFilePath
-} from "./chunk-556EWA6P.js";
+} from "./chunk-MLHNVYHT.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/skill-files.ts
 var skillFromFiles = (input, source = {}) => Effect_exports.gen(function* () {

package/js/{chunk-BKJDZYK7.js → chunk-7CSHVXVR.js}

@@ -3,15 +3,15 @@ import {
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-XEXUHXC3.js";
+} from "./chunk-3V575NIW.js";
 import {
   decoderOf,
   schemaArgument
-} from "./chunk-POOIHRPF.js";
+} from "./chunk-GHXRRFZA.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/authoring.ts
 var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");

package/js/{chunk-ZQWDOHEO.js → chunk-BO4US6DZ.js}

@@ -1,15 +1,15 @@
 import {
   skillFromFiles
-} from "./chunk-4U2VUDET.js";
+} from "./chunk-5TJA7364.js";
 import {
   joinPath,
   mergeMeta
-} from "./chunk-BKJDZYK7.js";
+} from "./chunk-7CSHVXVR.js";
 import {
   isShortenedUpstream,
   parseProviderError,
   providerError
-} from "./chunk-ENJCQWVF.js";
+} from "./chunk-E4BWL7KQ.js";
 import {
   ApiErrorResponse,
   HostDeclarationInvalid,
@@ -21,10 +21,7 @@ import {
   McpError,
   McpError2,
   SkillLoadFailed as SkillLoadFailed2
-} from "./chunk-XEXUHXC3.js";
-import {
-  AppDatabaseError
-} from "./chunk-73AV3JVU.js";
+} from "./chunk-3V575NIW.js";
 import {
   CacheError,
   FailureCode,
@@ -35,23 +32,19 @@ import {
   maxFailureFields,
   maxFailureMessageLength,
   maxUpstreamMessageLength
-} from "./chunk-BI6R577B.js";
+} from "./chunk-P7MGDPFD.js";
 import {
   SkillLoadFailed,
   skillFormatLimits
-} from "./chunk-556EWA6P.js";
+} from "./chunk-MLHNVYHT.js";
 import {
   jsonSchemaDocument
-} from "./chunk-POOIHRPF.js";
-import {
-  AppStorageError,
-  AppStorageUnavailable
-} from "./chunk-Y3XN4X4Q.js";
+} from "./chunk-GHXRRFZA.js";
 import {
   AccountId,
   HttpUrl,
   JsonObject
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   Cause_exports,
   Effect_exports,
@@ -61,7 +54,7 @@ import {
   Redacted_exports,
   Result_exports,
   Schema_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/contracts/openapi.ts
 var OpenapiErrorResponse = Schema_exports.Struct({
@@ -270,20 +263,6 @@ var OpenapiCompileError = class extends Schema_exports.TaggedError()(
 };
 
 // src/implementation/failure-detail.ts
-var storageMessages = {
-  schema: "The app's database schema is invalid.",
-  schema_changed: "The app's database schema changed during this operation. Retry it.",
-  table: "The operation used a table the app's database schema does not declare.",
-  index: "The operation used an index the table does not declare, or used it incorrectly.",
-  range: "The index range is invalid for the declared index.",
-  value: "A value does not match the table's declared field schema.",
-  readonly: "Queries cannot write. Move writes into a mutation.",
-  cursor: "The pagination cursor is invalid or belongs to a different query.",
-  limit: "The operation exceeded a per-invocation app data limit.",
-  closed: "The database session closed before this operation finished.",
-  storage: "App storage failed to complete the operation.",
-  replay: "A workflow step replayed with different input than its first run."
-};
 var cacheMessages = {
   capacity: "A cache key, value or batch exceeded the app cache's size limits.",
   invalid: "The app made a cache request the app cache could not accept.",
@@ -429,25 +408,6 @@ var failureDetail = (error, secrets) => {
       code: error.reason,
       message: cacheMessages[error.reason]
     };
-  if (Schema_exports.is(AppDatabaseError)(error))
-    return {
-      source: "storage",
-      errorName: "AppDatabaseError",
-      code: error.reason,
-      message: boundFailureMessage(ownMessage(error) ?? storageMessages[error.reason], secrets)
-    };
-  if (Schema_exports.is(AppStorageUnavailable)(error))
-    return {
-      source: "storage",
-      errorName: "AppStorageUnavailable",
-      message: "App storage is not available on this host."
-    };
-  if (Schema_exports.is(AppStorageError)(error))
-    return {
-      source: "storage",
-      errorName: "AppStorageError",
-      message: "App storage failed to complete the operation."
-    };
   if (Schema_exports.is(OpenapiError)(error))
     return {
       source: "service",

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