apps 0.0.1-beta.74 → 0.0.1-beta.76

package/js/{chunk-RUP4JMKO.js → chunk-A5JIYK7N.js}

@@ -1,9 +1,23 @@
+import {
+  appInvocationFetch
+} from "./chunk-BPROQMUB.js";
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-ZHHWNWV3.js";
 import {
   CacheAcquired,
   CacheEntry,
   CacheError,
   cacheLimits
-} from "./chunk-7LMU3ER3.js";
+} from "./chunk-Q4IZAUIF.js";
+import {
+  decoderOf
+} from "./chunk-KGCTYL2S.js";
+import {
+  owned
+} from "./chunk-3CVQ3VPP.js";
 import {
   Clock_exports,
   Duration_exports,
@@ -60,8 +74,16 @@ var makeCache = (host, background, scope = "shared", deadline) => {
       )
     )
   );
-  const get = (options, refresh) => Effect_exports.gen(function* () {
+  const get = (options, refresh, also = () => []) => Effect_exports.gen(function* () {
     const key = yield* keyOf(options.key);
+    const extra = also(key);
+    const reads = extra.length === 0 ? void 0 : yield* Effect_exports.forEach(extra, keyOf);
+    const withReads = (value, entries) => ({
+      value,
+      key,
+      reads: entries
+    });
+    const loaded = (value) => ({ value, key, reads: void 0 });
     const { fresh, stale } = yield* durations(options.freshFor, options.staleFor);
     const decode = (value) => Schema_exports.decodeUnknownEffect(options.schema)(value);
     const load = (lease) => Effect_exports.gen(function* () {
@@ -99,11 +121,12 @@ var makeCache = (host, background, scope = "shared", deadline) => {
     );
     let initialVersion;
     while (true) {
-      const { entry, lease } = yield* transport({
+      const acquired = yield* transport({
         operation: "acquire",
         key,
         refresh,
-        ...initialVersion === void 0 ? {} : { version: initialVersion }
+        ...initialVersion === void 0 ? {} : { version: initialVersion },
+        ...reads === void 0 ? {} : { reads }
       }).pipe(
         Effect_exports.flatMap(
           (reply) => Schema_exports.decodeUnknownEffect(CacheAcquired)(reply).pipe(
@@ -111,29 +134,33 @@ var makeCache = (host, background, scope = "shared", deadline) => {
           )
         )
       );
+      const { entry, lease } = acquired;
+      const together = acquired.reads?.length === reads?.length ? acquired.reads : void 0;
       const now = yield* Clock_exports.currentTimeMillis;
       if (initialVersion === void 0) initialVersion = entry?.version ?? null;
       const refreshed = refresh && entry !== null && entry.version !== initialVersion;
       if (entry !== null && (refreshed || !refresh && lease === null && now < entry.freshUntil)) {
         yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
-        return yield* decode(entry.value);
+        return withReads(yield* decode(entry.value), together);
       }
       const kept = !refresh && entry !== null && now < entry.staleUntil;
       if (kept && options.stale !== "revalidate") {
         yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
         if (lease !== null) yield* background(load(lease).pipe(Effect_exports.asVoid));
-        return yield* decode(entry.value);
+        return withReads(yield* decode(entry.value), together);
       }
       if (lease !== null) {
         yield* Effect_exports.annotateCurrentSpan("cache.result", kept ? "revalidated" : "miss");
-        return yield* load(lease);
+        return loaded(yield* load(lease));
       }
       if (now >= waitUntil) {
         yield* Effect_exports.annotateCurrentSpan("cache.result", "local");
-        return yield* options.load.pipe(
-          Effect_exports.flatMap(decode),
-          Effect_exports.timeout(cacheLimits.loadTimeoutMs),
-          Effect_exports.withSpan("app.cache.load", { attributes: { "cache.load.leased": false } })
+        return loaded(
+          yield* options.load.pipe(
+            Effect_exports.flatMap(decode),
+            Effect_exports.timeout(cacheLimits.loadTimeoutMs),
+            Effect_exports.withSpan("app.cache.load", { attributes: { "cache.load.leased": false } })
+          )
         );
       }
       yield* Effect_exports.sleep("100 millis");
@@ -171,13 +198,113 @@ var makeCache = (host, background, scope = "shared", deadline) => {
      * Read fresh data, refresh stale data in the background (or first, with `stale: "revalidate"`),
      * or wait for the lease owner.
      */
-    get: (options) => get(options, false),
+    get: (options) => get(options, false).pipe(Effect_exports.map(({ value }) => value)),
+    /**
+     * `get`, also reading the keys of this scope that `keys` names in the same round trip. `keys`
+     * gets the entry's store key, which is unique to this scope and key, so a caller can remember
+     * what it read under it. `reads` holds their entries, undecoded and in order, when the value
+     * was read from the store; it is undefined when the value was loaded or the store did not read
+     * them, and the caller then reads what it still needs.
+     */
+    getWith: (options, keys) => get(options, false, keys),
     /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
-    revalidate: (options) => get(options, true)
+    revalidate: (options) => get(options, true).pipe(Effect_exports.map(({ value }) => value))
+  };
+};
+
+// src/implementation/cache.ts
+var getWithReads = /* @__PURE__ */ Symbol("executor.cache.getWithReads");
+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, telemetry, deadline) => {
+  const scoped = (scope, callerSignal = signal) => {
+    const cache = makeCache(host.transport, host.background, scope, deadline);
+    const getOptions = (options) => ({
+      key: options.key,
+      schema: decoderOf(options.schema),
+      freshFor: options.freshFor,
+      ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
+      ...options.stale === void 0 ? {} : { stale: options.stale },
+      load: Effect_exports.acquireUseRelease(
+        Effect_exports.sync(() => new AbortController()),
+        (controller) => appInvocationFetch(controller.signal).pipe(
+          Effect_exports.flatMap(
+            (fetch) => fromPromise(
+              method(options, "load"),
+              "loader"
+            )({
+              fetch,
+              signal: controller.signal,
+              cache: scoped(scope, controller.signal)
+            })
+          )
+        ),
+        (controller) => Effect_exports.sync(() => controller.abort())
+      )
+    });
+    const load = (read, given) => cache[read](getOptions(given));
+    const decodeEntries = (entries, schema) => Effect_exports.forEach(
+      entries,
+      (entry) => entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value)
+    );
+    const service = (method2, operation) => toPromise(
+      (...args) => operation(...args).pipe(
+        owned("executor", "app.cache.call", { attributes: { "cache.method": method2 } })
+      ),
+      callerSignal,
+      telemetry
+    );
+    const authored = {
+      get: service("get", (options) => load("get", options)),
+      revalidate: service(
+        "revalidate",
+        (options) => load("revalidate", options)
+      ),
+      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);
+          })
+        )
+      ),
+      readMany: service(
+        "readMany",
+        (keys, schema) => cache.read(keys).pipe(Effect_exports.flatMap((entries) => decodeEntries(entries, schema)))
+      ),
+      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" });
+        return scoped(
+          { account: bound.id, method: bound.method, generation: bound.generation },
+          callerSignal
+        );
+      }
+    };
+    return Object.defineProperty(authored, getWithReads, {
+      value: service(
+        "get",
+        (given, keys) => cache.getWith(getOptions(given), keys).pipe(
+          Effect_exports.map(({ value, key, reads }) => ({
+            value,
+            key,
+            reads: reads?.map((entry) => entry === null ? void 0 : entry.value)
+          }))
+        )
+      )
+    });
   };
+  return scoped("shared");
 };
 
 export {
   cacheKey,
-  makeCache
+  getWithReads,
+  unavailableCache,
+  authorCache
 };

package/js/{chunk-MHB7IFG7.js → chunk-BPROQMUB.js}

@@ -5,7 +5,7 @@ import {
   networkRefusalHeader,
   networkRefusalStatus,
   supportedFetchOptions
-} from "./chunk-7LMU3ER3.js";
+} from "./chunk-Q4IZAUIF.js";
 import {
   invocationFetch
 } from "./chunk-3CVQ3VPP.js";

package/js/{chunk-2QWOG4UJ.js → chunk-D3EM6XUC.js}

@@ -1,10 +1,10 @@
 import {
   prepareElicitation
-} from "./chunk-UCQBJUA5.js";
+} from "./chunk-JREDSVGB.js";
 import {
   bodyUpstreamError,
   fromPromise
-} from "./chunk-ZR7QAG67.js";
+} from "./chunk-ZHHWNWV3.js";
 import {
   ElicitationFailed,
   McpError,
@@ -16,7 +16,7 @@ import {
   defaultElicitationLimits,
   defaultMcpClientLimits,
   mcpSdkTimerCeilingMs
-} from "./chunk-F2OAC6GE.js";
+} from "./chunk-EAVF4IPZ.js";
 import {
   jsonSchemaDecoder,
   nestJsonSchema,

package/js/{chunk-PZ535RJX.js → chunk-DFPNS3O3.js}

@@ -1,11 +1,11 @@
 import {
   fixedRouter
-} from "./chunk-TSPJFGA6.js";
+} from "./chunk-GLPG3W7P.js";
 import {
   nativeOperation,
   operationDeclaration,
   routerDeclaration
-} from "./chunk-OABWTKGG.js";
+} from "./chunk-L5OGF662.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {

package/js/{chunk-JSWN4D6V.js → chunk-DV6PXM42.js}

@@ -2,11 +2,11 @@ import {
   declaredOperations,
   nativeOperation,
   nativeRouter
-} from "./chunk-OABWTKGG.js";
+} from "./chunk-L5OGF662.js";
 import {
   fromPromise,
   method
-} from "./chunk-ZR7QAG67.js";
+} from "./chunk-ZHHWNWV3.js";
 import {
   EmittedEvent,
   EventName,
@@ -16,7 +16,7 @@ import {
   normalizePlacements,
   placementFields,
   renderPlacement
-} from "./chunk-F2OAC6GE.js";
+} from "./chunk-EAVF4IPZ.js";
 import {
   decoderOf,
   isSchema,

package/js/{chunk-F2OAC6GE.js → chunk-EAVF4IPZ.js}

@@ -6,7 +6,7 @@ import {
   FailureName,
   ProviderError,
   UpstreamError
-} from "./chunk-7LMU3ER3.js";
+} from "./chunk-Q4IZAUIF.js";
 import {
   AppSkillName,
   AppSkills

package/js/{chunk-TSPJFGA6.js → chunk-GLPG3W7P.js}

@@ -4,12 +4,12 @@ import {
 import {
   joinPath,
   mergeMeta
-} from "./chunk-OABWTKGG.js";
+} from "./chunk-L5OGF662.js";
 import {
   isShortenedUpstream,
   parseProviderError,
   providerError
-} from "./chunk-ZR7QAG67.js";
+} from "./chunk-ZHHWNWV3.js";
 import {
   ApiErrorResponse,
   HostDeclarationInvalid,
@@ -21,7 +21,7 @@ import {
   McpError,
   McpError2,
   SkillLoadFailed as SkillLoadFailed2
-} from "./chunk-F2OAC6GE.js";
+} from "./chunk-EAVF4IPZ.js";
 import {
   CacheError,
   FailureCode,
@@ -33,7 +33,7 @@ import {
   maxFailureFields,
   maxFailureMessageLength,
   maxUpstreamMessageLength
-} from "./chunk-7LMU3ER3.js";
+} from "./chunk-Q4IZAUIF.js";
 import {
   SkillLoadFailed,
   skillFormatLimits

package/js/{chunk-UCQBJUA5.js → chunk-JREDSVGB.js}

@@ -1,6 +1,7 @@
 import {
-  makeCache
-} from "./chunk-RUP4JMKO.js";
+  authorCache,
+  unavailableCache
+} from "./chunk-A5JIYK7N.js";
 import {
   accountSecrets,
   boundFailureMessage,
@@ -11,10 +12,10 @@ import {
   parseSkillLoadFailed,
   readCatalog,
   routerSkills
-} from "./chunk-TSPJFGA6.js";
+} from "./chunk-GLPG3W7P.js";
 import {
   appInvocationFetch
-} from "./chunk-MHB7IFG7.js";
+} from "./chunk-BPROQMUB.js";
 import {
   folderSkillsEffect
 } from "./chunk-XBG7HHXC.js";
@@ -25,21 +26,20 @@ import {
   makeEmitter,
   toEffectApp,
   withPlacements
-} from "./chunk-JSWN4D6V.js";
+} from "./chunk-DV6PXM42.js";
 import {
   declaredOperations,
   locate,
   nativeOperation
-} from "./chunk-OABWTKGG.js";
+} from "./chunk-L5OGF662.js";
 import {
   accountProviderError,
   appCode,
   fromPromise,
   httpProviderError,
-  method,
   parseProviderError,
   toPromise
-} from "./chunk-ZR7QAG67.js";
+} from "./chunk-ZHHWNWV3.js";
 import {
   AccountCheckResult,
   DeclaredProvider,
@@ -91,17 +91,13 @@ import {
   reservedTablePrefix,
   sqlBindingsLimit,
   workflowDurationMillis
-} from "./chunk-F2OAC6GE.js";
-import {
-  CacheError
-} from "./chunk-7LMU3ER3.js";
+} from "./chunk-EAVF4IPZ.js";
 import {
   AppSkills,
   SkillFile
 } from "./chunk-H72MEDMN.js";
 import {
   allowedValues,
-  decoderOf,
   echoableKey,
   importedJsonSchema,
   importedSchemaKeys,
@@ -1071,85 +1067,6 @@ var migrate = (storage, files) => Effect_exports.gen(function* () {
   );
 });
 
-// src/implementation/cache.ts
-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, telemetry, deadline) => {
-  const scoped = (scope, callerSignal = signal) => {
-    const cache = makeCache(host.transport, host.background, scope, deadline);
-    const load = (read, options) => cache[read]({
-      key: options.key,
-      schema: decoderOf(options.schema),
-      freshFor: options.freshFor,
-      ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
-      ...options.stale === void 0 ? {} : { stale: options.stale },
-      load: Effect_exports.acquireUseRelease(
-        Effect_exports.sync(() => new AbortController()),
-        (controller) => appInvocationFetch(controller.signal).pipe(
-          Effect_exports.flatMap(
-            (fetch) => fromPromise(
-              method(options, "load"),
-              "loader"
-            )({
-              fetch,
-              signal: controller.signal,
-              cache: scoped(scope, controller.signal)
-            })
-          )
-        ),
-        (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: service("get", (options) => load("get", options)),
-      revalidate: service(
-        "revalidate",
-        (options) => load("revalidate", options)
-      ),
-      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);
-          })
-        )
-      ),
-      readMany: service(
-        "readMany",
-        (keys, schema) => cache.read(keys).pipe(
-          Effect_exports.flatMap(
-            (entries) => Effect_exports.forEach(
-              entries,
-              (entry) => entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value)
-            )
-          )
-        )
-      ),
-      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" });
-        return scoped(
-          { account: bound.id, method: bound.method, generation: bound.generation },
-          callerSignal
-        );
-      }
-    };
-  };
-  return scoped("shared");
-};
-
 // src/implementation/host.ts
 var WireCatalog = Schema_exports.Struct({
   tools: Schema_exports.Array(Schema_exports.Union([HostedTool, HostedToolSummary])),
@@ -1200,24 +1117,24 @@ function providerDeclaration(provider) {
   return declarationSafe(
     () => Effect_exports.gen(function* () {
       const auth = /* @__PURE__ */ new Map();
-      for (const [name, method2] of Object.entries(provider.auth)) {
-        switch (method2._tag) {
+      for (const [name, method] of Object.entries(provider.auth)) {
+        switch (method._tag) {
           case "secrets":
             auth.set(name, {
               type: "secrets",
-              label: method2.label,
-              fields: yield* jsonSchemaDocument(method2.fields),
-              ...declaredExposure(method2.exposure),
-              ...declaredPlacements(method2.request)
+              label: method.label,
+              fields: yield* jsonSchemaDocument(method.fields),
+              ...declaredExposure(method.exposure),
+              ...declaredPlacements(method.request)
             });
             break;
           case "oauth2":
             auth.set(name, {
               type: "oauth2",
-              ...method2.config,
-              response: yield* jsonSchemaDocument(method2.response),
-              ...declaredExposure(method2.exposure),
-              ...declaredPlacements(method2.request)
+              ...method.config,
+              response: yield* jsonSchemaDocument(method.response),
+              ...declaredExposure(method.exposure),
+              ...declaredPlacements(method.request)
             });
             break;
         }
@@ -1271,9 +1188,9 @@ function withoutGrants({ hosts: _hosts, ...provider }) {
   return {
     ...provider,
     auth: Object.fromEntries(
-      Object.entries(provider.auth).map(([name, { request: _request, ...method2 }]) => [
+      Object.entries(provider.auth).map(([name, { request: _request, ...method }]) => [
         name,
-        method2
+        method
       ])
     )
   };
@@ -1305,10 +1222,10 @@ function bindAccounts(slots, declarations, context) {
           ids.add(account.id);
           if (canonical(withoutGrants(account.provider)) !== canonical(withoutGrants(requirement.definition)) || !Object.hasOwn(provider.auth, account.method))
             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 method = provider.auth[account.method];
+          if (method === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
           const fields = yield* Schema_exports.decodeUnknownEffect(
-            method2._tag === "secrets" ? method2.fields : method2.response
+            method._tag === "secrets" ? method.fields : method.response
           )(account.fields);
           const granted = Object.hasOwn(account.provider.auth, account.method) ? account.provider.auth[account.method]?.request : void 0;
           values.push(

package/js/{chunk-OABWTKGG.js → chunk-L5OGF662.js}

@@ -1,12 +1,12 @@
 import {
   fromPromise
-} from "./chunk-ZR7QAG67.js";
+} from "./chunk-ZHHWNWV3.js";
 import {
   HostedTool,
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-F2OAC6GE.js";
+} from "./chunk-EAVF4IPZ.js";
 import {
   decoderOf,
   schemaArgument

package/js/{chunk-AE45SVBH.js → chunk-PKFTT3HW.js}

@@ -3,16 +3,16 @@ import {
   answeredError,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-2QWOG4UJ.js";
+} from "./chunk-D3EM6XUC.js";
 import {
   failOnNetworkRefusal
-} from "./chunk-MHB7IFG7.js";
+} from "./chunk-BPROQMUB.js";
 import {
   accountProviderError,
   bodyUpstreamError,
   httpProviderError,
   providerErrorDetail
-} from "./chunk-ZR7QAG67.js";
+} from "./chunk-ZHHWNWV3.js";
 import {
   McpCredentialsUnverified,
   McpError,
@@ -20,11 +20,11 @@ import {
   McpToolsOptions,
   defaultMcpClientLimits,
   mcpHealthReserveMs
-} from "./chunk-F2OAC6GE.js";
+} from "./chunk-EAVF4IPZ.js";
 import {
   NetworkRefused,
   ProviderError
-} from "./chunk-7LMU3ER3.js";
+} from "./chunk-Q4IZAUIF.js";
 import {
   captureTelemetry,
   owned

package/js/{chunk-7LMU3ER3.js → chunk-Q4IZAUIF.js}

@@ -203,7 +203,13 @@ var CacheEntry = Schema_exports.Struct({
 });
 var CacheAcquired = Schema_exports.Struct({
   entry: Schema_exports.NullOr(CacheEntry),
-  lease: Schema_exports.NullOr(Schema_exports.String)
+  lease: Schema_exports.NullOr(Schema_exports.String),
+  /**
+   * The entries of the command's `reads`, in order, read in the same transaction as `entry`.
+   * Absent when the store did not read them: a store that predates them, or reads past the
+   * batch byte bound. The caller then reads them with a separate `read`.
+   */
+  reads: Schema_exports.optionalKey(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))
 });
 var CacheCommand = Schema_exports.Union([
   Schema_exports.Struct({ operation: Schema_exports.Literal("read"), keys: Schema_exports.Array(Key) }),
@@ -213,7 +219,12 @@ var CacheCommand = Schema_exports.Union([
     /** Claim even a fresh entry, as an explicit refresh does. */
     refresh: Schema_exports.Boolean,
     /** Claim only while the entry still has this version. Absent accepts the current one. */
-    version: Schema_exports.optionalKey(Schema_exports.NullOr(Schema_exports.String))
+    version: Schema_exports.optionalKey(Schema_exports.NullOr(Schema_exports.String)),
+    /**
+     * Other keys to read in the same transaction, as `read` would, so a caller that needs them
+     * beside the entry makes one round trip. Reading them claims and changes nothing.
+     */
+    reads: Schema_exports.optionalKey(Schema_exports.Array(Key))
   }),
   Schema_exports.Struct({
     operation: Schema_exports.Literal("claim"),