apps 0.0.1-beta.44 → 0.0.1-beta.46

package/js/{chunk-EMHFXFTJ.js → chunk-LTDHQJ2Z.js}

@@ -2,14 +2,63 @@ import {
   ProviderError,
   maxUpstreamMessageLength
 } from "./chunk-MWKHKOTL.js";
+import {
+  owned
+} from "./chunk-JM7LOD2W.js";
 import {
   AccountId
 } from "./chunk-H2CJWXA3.js";
 import {
+  Effect_exports,
   Option_exports,
   Schema_exports
 } from "./chunk-IFJU5SYQ.js";
 
+// src/implementation/authoring.ts
+var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
+var appCode = (code) => owned("app", "app.code", { attributes: { "executor.app.code": code } });
+var fromPromise = (callback, code) => (...args) => {
+  if (NativeCallback in callback) {
+    const native = callback[NativeCallback];
+    return native(...args);
+  }
+  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error }).pipe(
+    appCode(code)
+  );
+};
+var method = (target, key) => {
+  const value = target[key];
+  const call = (...args) => Reflect.apply(value, target, args);
+  if (NativeCallback in value) Object.assign(call, { [NativeCallback]: value[NativeCallback] });
+  return call;
+};
+var toPromise = (operation, signalOf, services) => {
+  const native = (...args) => Effect_exports.suspend(() => {
+    const signal = typeof signalOf === "function" ? signalOf(...args) : signalOf;
+    if (signal === void 0) return operation(...args);
+    if (signal.aborted) return Effect_exports.interrupt;
+    const cancelled = Effect_exports.callback((resume) => {
+      if (signal.aborted) {
+        resume(Effect_exports.interrupt);
+        return;
+      }
+      const abort = () => resume(Effect_exports.interrupt);
+      signal.addEventListener("abort", abort, { once: true });
+      return Effect_exports.sync(() => signal.removeEventListener("abort", abort));
+    });
+    return Effect_exports.raceFirst(
+      cancelled,
+      Effect_exports.suspend(() => operation(...args))
+    );
+  });
+  return Object.assign(
+    (...args) => services === void 0 ? Effect_exports.runPromise(native(...args)) : Effect_exports.runPromiseWith(services)(native(...args)),
+    {
+      [NativeCallback]: native
+    }
+  );
+};
+
 // src/implementation/upstream-error.ts
 var ErrorToken = Schema_exports.String.check(Schema_exports.isPattern(/^[A-Za-z0-9._-]{1,128}$/u));
 var JsonRpcError = Schema_exports.Struct({
@@ -107,6 +156,10 @@ function graphqlProviderError(errors, status) {
 }
 
 export {
+  appCode,
+  fromPromise,
+  method,
+  toPromise,
   isShortenedUpstream,
   bodyUpstreamError,
   providerError,

package/js/{chunk-DRJRCHHO.js → chunk-OJ47HQVJ.js}

@@ -11,10 +11,10 @@ import {
   parseSkillLoadFailed,
   readCatalog,
   routerSkills
-} from "./chunk-5SHUB37R.js";
+} from "./chunk-3UGDI2UI.js";
 import {
   appInvocationFetch
-} from "./chunk-DZQYE626.js";
+} from "./chunk-7UUHJR2Q.js";
 import {
   folderSkillsEffect
 } from "./chunk-XBG7HHXC.js";
@@ -22,19 +22,21 @@ import {
   ResponseStatusError,
   isApp,
   toEffectApp
-} from "./chunk-646JVUH4.js";
+} from "./chunk-3B2JAOSE.js";
 import {
   declaredOperations,
-  fromPromise,
   locate,
-  nativeOperation,
-  toPromise
-} from "./chunk-OTGUPKKK.js";
+  nativeOperation
+} from "./chunk-LHCGND3R.js";
 import {
   accountProviderError,
+  appCode,
+  fromPromise,
   httpProviderError,
-  parseProviderError
-} from "./chunk-EMHFXFTJ.js";
+  method,
+  parseProviderError,
+  toPromise
+} from "./chunk-LTDHQJ2Z.js";
 import {
   AccountCheckResult,
   DeclaredProvider,
@@ -63,6 +65,7 @@ import {
   HostedWebhook,
   HostedWorkflow,
   InvocationDeadline,
+  InvocationTimingSink,
   ManualWebhookSetup,
   ManyAccounts,
   NonRetryableError,
@@ -83,7 +86,7 @@ import {
   migrationsDirectory,
   reservedTablePrefix,
   workflowDurationMillis
-} from "./chunk-ELO5PRCO.js";
+} from "./chunk-CVAJ4F6O.js";
 import {
   CacheError
 } from "./chunk-MWKHKOTL.js";
@@ -91,9 +94,6 @@ import {
   AppSkills,
   SkillFile
 } from "./chunk-H72MEDMN.js";
-import {
-  captureTelemetry
-} from "./chunk-CZGWW4NQ.js";
 import {
   allowedValues,
   decoderOf,
@@ -108,6 +108,12 @@ import {
   objectShape,
   unionShape
 } from "./chunk-KGCTYL2S.js";
+import {
+  captureTelemetry,
+  makeOwnershipAccounting,
+  measuredSpan,
+  owned
+} from "./chunk-JM7LOD2W.js";
 import {
   JsonObject,
   JsonValue
@@ -126,6 +132,34 @@ import {
   Stream_exports
 } from "./chunk-IFJU5SYQ.js";
 
+// src/implementation/invocation-timing.ts
+var elicitationWaitSpan = "app.elicitation.wait";
+var workflowControlSpan = "app.workflow.control";
+var timedInvocation = (operation) => (effect) => Effect_exports.gen(function* () {
+  const report = yield* InvocationTimingSink;
+  return yield* effect.pipe(
+    measuredSpan(`app.${operation}`, {}, (start) => {
+      const accounting = makeOwnershipAccounting(start, "executor");
+      return {
+        around: accounting.observe,
+        end: (end, span) => {
+          const spent = accounting.read(end);
+          report({
+            elapsedMs: Number(end - start) / 1e6,
+            upstreamMs: spent.upstream,
+            elicitationMs: spent.person,
+            authoredMs: spent.app
+          });
+          span.attribute("executor.upstream.wait_ms", spent.upstream);
+          span.attribute("executor.elicitation.wait_ms", spent.person);
+          span.attribute("executor.authored_ms", spent.app);
+          span.attribute("executor.overhead_ms", spent.executor);
+        }
+      };
+    })
+  );
+});
+
 // src/implementation/elicitation.ts
 var prepareElicitation = (input) => Effect_exports.gen(function* () {
   const request = yield* Schema_exports.decodeUnknownEffect(FormElicitation)(input, {
@@ -152,13 +186,17 @@ var prepareElicitation = (input) => Effect_exports.gen(function* () {
   });
   return { request, respond };
 });
-var makeElicit = (handler, signal) => toPromise(
+var makeElicit = (handler, signal, telemetry) => toPromise(
   (input) => Effect_exports.gen(function* () {
     if (handler === void 0) return yield* new ElicitationFailed({ reason: "unavailable" });
     const form = yield* prepareElicitation(input);
-    return yield* handler(form.request, signal).pipe(Effect_exports.flatMap(form.respond));
+    return yield* handler(form.request, signal).pipe(
+      owned("person", elicitationWaitSpan),
+      Effect_exports.flatMap(form.respond)
+    );
   }),
-  signal
+  signal,
+  telemetry
 );
 
 // src/contracts/approval.ts
@@ -244,10 +282,7 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
             );
             const step2 = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
             const result = yield* workflowSafe(
-              Effect_exports.tryPromise({
-                try: () => callback(step2.context),
-                catch: (error) => error
-              }),
+              fromPromise(callback, "step")(step2.context),
               step2.secrets
             );
             return yield* Schema_exports.decodeUnknownEffect(WorkflowValue)(result).pipe(
@@ -605,7 +640,8 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
             return yield* new HostOutputInvalid();
           chunks.push(chunk);
         })
-      )
+      ),
+      appCode("webhook")
     );
   const bytes = new Uint8Array(size);
   let offset = 0;
@@ -849,9 +885,12 @@ var MigrationFailed = class extends Schema_exports.TaggedError()("MigrationFaile
   }
 };
 var migrationName = /^(\d+)_[A-Za-z0-9_-]+\.sql$/;
-var sha256 = (text) => Effect_exports.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))).pipe(
-  Effect_exports.map(
-    (digest) => Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+var sha256 = (text) => (
+  // oxlint-disable-next-line executor/authored-code-through-adapter -- Web Crypto
+  Effect_exports.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))).pipe(
+    Effect_exports.map(
+      (digest) => Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+    )
   )
 );
 var hasMigrations = (files) => files.some(
@@ -959,10 +998,10 @@ var unavailableCache = {
   transport: () => Effect_exports.fail(new CacheError({ reason: "unavailable" })),
   background: () => Effect_exports.die(new Error("Cache background runner is unavailable"))
 };
-var authorCache = (host, accounts, signal, deadline) => {
+var authorCache = (host, accounts, signal, telemetry, deadline) => {
   const scoped = (scope, callerSignal = signal) => {
     const cache = makeCache(host.transport, host.background, scope, deadline);
-    const load = (method, options) => cache[method]({
+    const load = (read, options) => cache[read]({
       key: options.key,
       schema: decoderOf(options.schema),
       freshFor: options.freshFor,
@@ -972,7 +1011,10 @@ var authorCache = (host, accounts, signal, deadline) => {
         Effect_exports.sync(() => new AbortController()),
         (controller) => appInvocationFetch(controller.signal).pipe(
           Effect_exports.flatMap(
-            (fetch) => fromPromise(options.load)({
+            (fetch) => fromPromise(
+              method(options, "load"),
+              "loader"
+            )({
               fetch,
               signal: controller.signal,
               cache: scoped(scope, controller.signal)
@@ -982,22 +1024,30 @@ var authorCache = (host, accounts, signal, deadline) => {
         (controller) => Effect_exports.sync(() => controller.abort())
       )
     });
+    const service = (method2, operation) => toPromise(
+      (...args) => operation(...args).pipe(
+        owned("executor", "app.cache.call", { attributes: { "cache.method": method2 } })
+      ),
+      callerSignal,
+      telemetry
+    );
     return {
-      get: toPromise((options) => load("get", options), callerSignal),
-      revalidate: toPromise(
-        (options) => load("revalidate", options),
-        callerSignal
+      get: service("get", (options) => load("get", options)),
+      revalidate: service(
+        "revalidate",
+        (options) => load("revalidate", options)
       ),
-      read: toPromise(
+      read: service(
+        "read",
         (key, schema) => cache.read([key]).pipe(
           Effect_exports.flatMap((entries) => {
             const entry = entries[0];
             return entry === void 0 || entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value);
           })
-        ),
-        callerSignal
+        )
       ),
-      readMany: toPromise(
+      readMany: service(
+        "readMany",
         (keys, schema) => cache.read(keys).pipe(
           Effect_exports.flatMap(
             (entries) => Effect_exports.forEach(
@@ -1005,11 +1055,10 @@ var authorCache = (host, accounts, signal, deadline) => {
               (entry) => entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value)
             )
           )
-        ),
-        callerSignal
+        )
       ),
-      write: toPromise(cache.write, callerSignal),
-      invalidate: toPromise(cache.invalidate, callerSignal),
+      write: service("write", cache.write),
+      invalidate: service("invalidate", cache.invalidate),
       forAccount: (account) => {
         const bound = Object.values(accounts).flatMap((value) => Array.isArray(value) ? value : [value]).find((value) => value.id === account.id);
         if (bound === void 0) throw new CacheError({ reason: "invalid" });
@@ -1070,22 +1119,22 @@ function providerDeclaration(provider) {
   return declarationSafe(
     () => Effect_exports.gen(function* () {
       const auth = /* @__PURE__ */ new Map();
-      for (const [name, method] of Object.entries(provider.auth)) {
-        switch (method._tag) {
+      for (const [name, method2] of Object.entries(provider.auth)) {
+        switch (method2._tag) {
           case "secrets":
             auth.set(name, {
               type: "secrets",
-              label: method.label,
-              fields: yield* jsonSchemaDocument(method.fields),
-              ...declaredExposure(method.exposure)
+              label: method2.label,
+              fields: yield* jsonSchemaDocument(method2.fields),
+              ...declaredExposure(method2.exposure)
             });
             break;
           case "oauth2":
             auth.set(name, {
               type: "oauth2",
-              ...method.config,
-              response: yield* jsonSchemaDocument(method.response),
-              ...declaredExposure(method.exposure)
+              ...method2.config,
+              response: yield* jsonSchemaDocument(method2.response),
+              ...declaredExposure(method2.exposure)
             });
             break;
         }
@@ -1159,10 +1208,10 @@ function bindAccounts(slots, declarations, context) {
           ids.add(account.id);
           if (canonical(withoutHosts(account.provider)) !== canonical(withoutHosts(requirement.definition)) || !Object.hasOwn(provider.auth, account.method))
             return yield* Effect_exports.fail(new HostAccountsInvalid());
-          const method = provider.auth[account.method];
-          if (method === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
+          const method2 = provider.auth[account.method];
+          if (method2 === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
           const fields = yield* Schema_exports.decodeUnknownEffect(
-            method._tag === "secrets" ? method.fields : method.response
+            method2._tag === "secrets" ? method2.fields : method2.response
           )(account.fields);
           values.push({ id: account.id, method: account.method, fields });
         }
@@ -1299,27 +1348,50 @@ function dispatch(app, request, context, signal) {
       let running;
       const delivery = (request2, signal2) => Effect_exports.suspend(
         () => running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
-          Effect_exports.withSpan("app.tool.elicitation"),
+          // Delivering the question and waiting for its answer is the person's time.
+          owned("person", "app.tool.elicitation"),
           Effect_exports.provideContext(running.context)
         ) : Effect_exports.fail(new ElicitationFailed({ reason: "unavailable" }))
       );
       const unavailableWorkflow = () => Effect_exports.fail(new WorkflowFailure({ reason: "unavailable", retryable: false }));
+      const telemetry = yield* captureTelemetry;
+      const control = (operation, work) => work.pipe(
+        owned("executor", workflowControlSpan, {
+          attributes: { "executor.workflow.operation": operation }
+        })
+      );
       const workflowControls = {
         start: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.start(input2),
-          invocationSignal
+          (input2) => control(
+            "start",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.start(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         ),
         get: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.get(input2),
-          invocationSignal
+          (input2) => control(
+            "get",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.get(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         ),
         list: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.list(input2),
-          invocationSignal
+          (input2) => control(
+            "list",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.list(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         ),
         terminate: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.terminate(input2),
-          invocationSignal
+          (input2) => control(
+            "terminate",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.terminate(input2)
+          ),
+          invocationSignal,
+          telemetry.context
         )
       };
       const workflowReads = {
@@ -1344,6 +1416,7 @@ function dispatch(app, request, context, signal) {
           },
           Redacted_exports.value(context.accounts),
           invocationSignal,
+          telemetry.context,
           deadline
         ),
         files,
@@ -1353,7 +1426,7 @@ function dispatch(app, request, context, signal) {
         workflows: workflowReads,
         signal: invocationSignal,
         fetch: yield* appInvocationFetch(fetching.signal),
-        elicit: makeElicit(delivery, invocationSignal)
+        elicit: makeElicit(delivery, invocationSignal, telemetry.context)
       };
       const definition = yield* evaluationSafe(native.evaluate(bound), secrets).pipe(
         Effect_exports.withSpan("app.evaluate")
@@ -1426,7 +1499,8 @@ function dispatch(app, request, context, signal) {
                 cache: authorCache(
                   context.cache ?? unavailableCache,
                   Redacted_exports.value(current.accounts),
-                  signal2
+                  signal2,
+                  (yield* captureTelemetry).context
                 ),
                 files,
                 fetch: yield* appInvocationFetch(signal2),
@@ -1495,7 +1569,9 @@ function dispatch(app, request, context, signal) {
       }
       const toolName = request.operation === "call" ? request.tool : request.name;
       const location = locate(definition.tools, toolName);
-      const tool = location === void 0 ? void 0 : location.kind === "operation" ? location.operation : yield* evaluationSafe(location.source.resolve(location.name), secrets);
+      const tool = location === void 0 ? void 0 : location.kind === "operation" ? location.operation : yield* evaluationSafe(location.source.resolve(location.name), secrets).pipe(
+        Effect_exports.withSpan("app.tool.resolve")
+      );
       if (tool === void 0)
         return yield* request.operation === "call" ? new HostToolNotFound() : new HostOperationNotFound();
       const requested = request.operation === "call" ? request.kind : request.operation === "query" ? "query" : "mutation";
@@ -1710,7 +1786,9 @@ var createAppHandler = (app) => (request, context) => Effect_exports.gen(functio
         ...error.code === void 0 ? {} : { "executor.failure.code": error.code }
       }) : Effect_exports.void
     ),
-    Effect_exports.withSpan(`app.${command.operation}`)
+    // Tool operations time themselves, dividing their time by who owned the work in progress.
+    // Other operations do not.
+    command.operation === "call" || command.operation === "query" || command.operation === "mutate" ? timedInvocation(command.operation) : Effect_exports.withSpan(`app.${command.operation}`)
   );
   if (toolError)
     yield* Effect_exports.annotateCurrentSpan({

package/js/{chunk-MZH4J2PO.js → chunk-PD6I2SDG.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-LNSVJS2Q.js";
+} from "./chunk-EOPQ727L.js";
 import {
   Reference,
   Service,

package/js/{chunk-KSGYJV46.js → chunk-TUMGL2OC.js}

@@ -19,7 +19,7 @@ import {
   text,
   uint8Array,
   urlParams
-} from "./chunk-LNSVJS2Q.js";
+} from "./chunk-EOPQ727L.js";
 import {
   Cause,
   Defect,

package/js/{chunk-5GLC42LK.js → chunk-UM62MBJQ.js}

@@ -1,3 +1,8 @@
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-LTDHQJ2Z.js";
 import {
   CacheError
 } from "./chunk-MWKHKOTL.js";
@@ -8,6 +13,7 @@ import {
   JsonObject
 } from "./chunk-H2CJWXA3.js";
 import {
+  Deferred_exports,
   Duration_exports,
   Effect_exports,
   Schema_exports
@@ -31,7 +37,6 @@ var Manifest = Schema_exports.Struct({
   summaries: Schema_exports.Int,
   header: Schema_exports.optionalKey(JsonObject)
 });
-var invoke = (work) => Effect_exports.tryPromise({ try: work, catch: (error) => error });
 var catalogCache = (options) => Effect_exports.gen(function* () {
   const cache = options.cache;
   const key = [...options.prefix, "current"];
@@ -48,14 +53,12 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
   const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
     const batches = yield* Effect_exports.forEach(
       Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
-      (offset) => invoke(
-        () => cache2.readMany(
-          Array.from(
-            { length: Math.min(4, count - offset) },
-            (_, index) => part(revision, kind, offset + index)
-          ),
-          schema(Schema_exports.Array(decoder))
-        )
+      (offset) => fromPromise(method(cache2, "readMany"), "cache")(
+        Array.from(
+          { length: Math.min(4, count - offset) },
+          (_, index) => part(revision, kind, offset + index)
+        ),
+        schema(Schema_exports.Array(decoder))
       ),
       { concurrency: "unbounded" }
     );
@@ -66,7 +69,7 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     }
     return values;
   });
-  const kept = (cache2) => invoke(() => cache2.read(key, schema(Manifest))).pipe(
+  const kept = (cache2) => fromPromise(method(cache2, "read"), "cache")(key, schema(Manifest)).pipe(
     Effect_exports.map(
       (manifest) => manifest === void 0 ? void 0 : {
         header: manifest.header,
@@ -76,12 +79,13 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
   );
   const refresh = (context) => Effect_exports.gen(function* () {
     const { tools, header } = yield* options.load(context, kept(context.cache));
-    const digest = yield* invoke(
-      () => crypto.subtle.digest(
+    const digest = yield* Effect_exports.tryPromise({
+      try: () => crypto.subtle.digest(
         "SHA-256",
         new TextEncoder().encode(JSON.stringify({ tools, header: header ?? null }))
-      )
-    );
+      ),
+      catch: (error) => error
+    });
     const revision = Array.from(
       new Uint8Array(digest),
       (byte) => byte.toString(16).padStart(2, "0")
@@ -101,7 +105,7 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
       batch = [];
       batchBytes = 0;
       if (!entries.length) return Effect_exports.void;
-      return invoke(() => context.cache.write(entries, retention)).pipe(
+      return fromPromise(method(context.cache, "write"), "cache")(entries, retention).pipe(
         Effect_exports.withSpan("app.cache.flush", {
           attributes: {
             "cache.flush.index": flushes++,
@@ -160,17 +164,30 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     freshFor,
     staleFor,
     ...options.stale === void 0 ? {} : { stale: options.stale },
-    load: (context) => Effect_exports.runPromise(refresh(context), { signal: context.signal })
+    // A cache may call the loader as a Promise; its own signal cancels that load.
+    load: toPromise(refresh, (context) => context.signal)
   };
   let reading;
-  const current = () => cache === void 0 ? Effect_exports.fail(new CacheError({ reason: "unavailable" })) : invoke(
-    () => reading ??= cache.get(getOptions).finally(() => {
-      reading = void 0;
-    })
-  );
+  const current = () => Effect_exports.suspend(() => {
+    if (cache === void 0) return Effect_exports.fail(new CacheError({ reason: "unavailable" }));
+    const shared = reading;
+    if (shared !== void 0) return Deferred_exports.await(shared);
+    const deferred = Deferred_exports.makeUnsafe();
+    reading = deferred;
+    return fromPromise(
+      method(cache, "get"),
+      "cache"
+    )(getOptions).pipe(
+      Effect_exports.onExit(
+        (exit) => Effect_exports.sync(() => {
+          if (reading === deferred) reading = void 0;
+        }).pipe(Effect_exports.andThen(Deferred_exports.done(deferred, exit)))
+      )
+    );
+  });
   if (options.revalidate) {
     if (cache === void 0) yield* local;
-    else yield* invoke(() => cache.revalidate(getOptions));
+    else yield* fromPromise(method(cache, "revalidate"), "cache")(getOptions);
   }
   const metadata = () => Effect_exports.gen(function* () {
     if (cache === void 0) return (yield* local).tools;
@@ -195,8 +212,9 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     }),
     resolve: (name) => cache === void 0 ? local.pipe(Effect_exports.map(({ tools }) => tools.find((tool) => tool.name === name))) : current().pipe(
       Effect_exports.flatMap(
-        (manifest) => invoke(
-          () => cache.read(part(manifest.revision, "tool", name), schema(options.schema))
+        (manifest) => fromPromise(method(cache, "read"), "cache")(
+          part(manifest.revision, "tool", name),
+          schema(options.schema)
         )
       )
     )