apps 0.0.1-beta.1 → 0.0.1-beta.3

package/js/browser-XIPJGLH2.js

@@ -0,0 +1,65 @@
+import {
+  Alias,
+  Composer,
+  Document,
+  Lexer,
+  LineCounter,
+  Pair,
+  Parser,
+  Scalar,
+  Schema,
+  YAMLError,
+  YAMLMap,
+  YAMLParseError,
+  YAMLSeq,
+  YAMLWarning,
+  browser_default,
+  cst_exports,
+  isAlias,
+  isCollection,
+  isDocument,
+  isMap,
+  isNode,
+  isPair,
+  isScalar,
+  isSeq,
+  parse,
+  parseAllDocuments,
+  parseDocument,
+  stringify,
+  visit,
+  visitAsync
+} from "./chunk-UVL56Z6E.js";
+import "./chunk-CZ7CSFO4.js";
+export {
+  Alias,
+  cst_exports as CST,
+  Composer,
+  Document,
+  Lexer,
+  LineCounter,
+  Pair,
+  Parser,
+  Scalar,
+  Schema,
+  YAMLError,
+  YAMLMap,
+  YAMLParseError,
+  YAMLSeq,
+  YAMLWarning,
+  browser_default as default,
+  isAlias,
+  isCollection,
+  isDocument,
+  isMap,
+  isNode,
+  isPair,
+  isScalar,
+  isSeq,
+  parse,
+  parseAllDocuments,
+  parseDocument,
+  stringify,
+  visit,
+  visitAsync
+};

package/js/{chunk-6YBRWRK3.js → chunk-5MQZEB6Y.js}

@@ -1,9 +1,9 @@
 import {
   CacheError
-} from "./chunk-RBAC33PQ.js";
+} from "./chunk-LGIYBDWA.js";
 import {
   wrap
-} from "./chunk-2HHMABB6.js";
+} from "./chunk-WFSQXYUT.js";
 import {
   JsonObject
 } from "./chunk-SATWJKN6.js";
@@ -51,10 +51,22 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     let summaryBytes = 0;
     let batch = [];
     let batchBytes = 0;
-    const flush = () => invoke(async () => {
-      if (batch.length) await context.cache.write(batch, retention);
+    let flushes = 0;
+    const flush = () => Effect_exports.suspend(() => {
+      const entries = batch;
+      const bytes = batchBytes;
       batch = [];
       batchBytes = 0;
+      if (!entries.length) return Effect_exports.void;
+      return invoke(() => context.cache.write(entries, retention)).pipe(
+        Effect_exports.withSpan("app.cache.flush", {
+          attributes: {
+            "cache.flush.index": flushes++,
+            "cache.flush.entries": entries.length,
+            "cache.flush.bytes": bytes
+          }
+        })
+      );
     });
     const append = (entry) => Effect_exports.gen(function* () {
       const bytes = new TextEncoder().encode(JSON.stringify(entry)).byteLength;

package/js/chunk-D47C7KG5.js

@@ -0,0 +1,172 @@
+import {
+  CacheAcquired,
+  CacheEntry,
+  CacheError,
+  cacheLimits
+} from "./chunk-LGIYBDWA.js";
+import {
+  Clock_exports,
+  Duration_exports,
+  Effect_exports,
+  Exit_exports,
+  Schema_exports
+} from "./chunk-FW5HBOIK.js";
+
+// ../app-cache/src/index.ts
+var canonical = (value) => {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  return JSON.stringify(value);
+};
+var cacheKey = (key) => Effect_exports.gen(function* () {
+  const parsed = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(key).pipe(
+    Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
+  );
+  const bytes = new TextEncoder().encode(canonical(parsed));
+  if (bytes.byteLength > cacheLimits.keyBytes)
+    return yield* new CacheError({ reason: "capacity" });
+  const hash = yield* Effect_exports.tryPromise({
+    try: () => crypto.subtle.digest("SHA-256", bytes),
+    catch: () => new CacheError({ reason: "invalid" })
+  });
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+});
+var makeCache = (host, background, scope = "shared", deadline) => {
+  const transport = (command) => host(command).pipe(
+    Effect_exports.withSpan("app.cache.command", {
+      attributes: { "cache.operation": command.operation }
+    })
+  );
+  const keyOf = (key) => cacheKey([scope, key]);
+  const readKeys = (keys) => transport({ operation: "read", keys }).pipe(
+    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))),
+    Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
+  );
+  const durations = (freshFor, staleFor = 0) => Effect_exports.try({
+    try: () => {
+      const fresh = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor));
+      const stale = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor));
+      if (![fresh, stale].every((value) => Number.isFinite(value) && value >= 0) || fresh + stale > cacheLimits.retentionMs)
+        throw new CacheError({ reason: "invalid" });
+      return { fresh, stale };
+    },
+    catch: () => new CacheError({ reason: "invalid" })
+  });
+  const get = (options, refresh) => Effect_exports.gen(function* () {
+    const key = yield* keyOf(options.key);
+    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* () {
+      const value = yield* options.load.pipe(Effect_exports.flatMap(decode));
+      const json = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(value).pipe(
+        Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
+      );
+      const now = yield* Clock_exports.currentTimeMillis;
+      const published = yield* transport({
+        operation: "publish",
+        key,
+        lease,
+        entry: {
+          value: json,
+          version: crypto.randomUUID(),
+          freshUntil: now + fresh,
+          staleUntil: now + fresh + stale
+        }
+      }).pipe(Effect_exports.withSpan("app.cache.publish"));
+      if (published !== true) return yield* new CacheError({ reason: "unavailable" });
+      return value;
+    }).pipe(
+      Effect_exports.withSpan("app.cache.load"),
+      Effect_exports.timeout(cacheLimits.loadTimeoutMs),
+      // Publishing clears the lease in the same transaction. Only an unpublished load releases it.
+      Effect_exports.onExit(
+        (exit) => Exit_exports.isSuccess(exit) ? Effect_exports.void : transport({ operation: "release", key, lease }).pipe(
+          Effect_exports.catch(() => Effect_exports.void)
+        )
+      )
+    );
+    const waitUntil = Math.min(
+      (yield* Clock_exports.currentTimeMillis) + cacheLimits.waitMs,
+      deadline ?? Number.POSITIVE_INFINITY
+    );
+    let initialVersion;
+    while (true) {
+      const { entry, lease } = yield* transport({
+        operation: "acquire",
+        key,
+        refresh,
+        ...initialVersion === void 0 ? {} : { version: initialVersion }
+      }).pipe(
+        Effect_exports.flatMap(
+          (reply) => Schema_exports.decodeUnknownEffect(CacheAcquired)(reply).pipe(
+            Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
+          )
+        )
+      );
+      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);
+      }
+      if (!refresh && entry !== null && now < entry.staleUntil) {
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
+        if (lease !== null) yield* background(load(lease).pipe(Effect_exports.asVoid));
+        return yield* decode(entry.value);
+      }
+      if (lease !== null) {
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "miss");
+        return 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 } })
+        );
+      }
+      yield* Effect_exports.sleep("100 millis");
+    }
+  }).pipe(Effect_exports.withSpan("app.cache.get"));
+  return {
+    /** Read arbitrary retained JSON entries without initiating a refresh. Missing and null are distinct. */
+    read: (keys) => Effect_exports.forEach(keys, keyOf).pipe(Effect_exports.flatMap(readKeys)),
+    /** Publish bounded immutable parts before publishing the manifest that references them. */
+    write: (entries, retention) => Effect_exports.gen(function* () {
+      const { fresh } = yield* durations(retention);
+      const now = yield* Clock_exports.currentTimeMillis;
+      const values = yield* Effect_exports.forEach(
+        entries,
+        ({ key, value }) => Effect_exports.gen(function* () {
+          return {
+            key: yield* keyOf(key),
+            entry: {
+              value,
+              version: crypto.randomUUID(),
+              freshUntil: now + fresh,
+              staleUntil: now + fresh
+            }
+          };
+        })
+      );
+      yield* transport({ operation: "write", entries: values });
+    }),
+    /** Revoke retained data and any loader's right to publish its in-flight result. */
+    invalidate: (key) => keyOf(key).pipe(
+      Effect_exports.flatMap((key2) => transport({ operation: "invalidate", key: key2 })),
+      Effect_exports.asVoid
+    ),
+    /** Read fresh data, refresh stale data in the background, or wait for the lease owner. */
+    get: (options) => get(options, false),
+    /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
+    revalidate: (options) => get(options, true)
+  };
+};
+
+export {
+  cacheKey,
+  makeCache
+};

package/js/{chunk-ZTFQHGEB.js → chunk-FDNTX5QJ.js}

@@ -1,6 +1,3 @@
-import {
-  parseDocument
-} from "./chunk-NCYXZN2G.js";
 import {
   AppSkillMetadata,
   AppSkillName,
@@ -28,6 +25,7 @@ var skillFromFiles = (input, source = {}) => Effect_exports.gen(function* () {
   );
   if (match?.[1] === void 0) return yield* invalid("frontmatter");
   const frontmatter = match[1];
+  const { parseDocument } = (yield* Effect_exports.promise(() => import("./browser-XIPJGLH2.js"))).default;
   const value = yield* Effect_exports.try({
     try: () => {
       const yaml = parseDocument(frontmatter);

package/js/{chunk-OHRT55C4.js → chunk-G7ZIRKMK.js}

@@ -1784,10 +1784,7 @@ var AppUiApi = HttpApi_exports.make("app-ui").add(
 );
 
 export {
-  HttpApiEndpoint_exports,
-  HttpApi_exports,
   HttpApiClient_exports,
-  HttpApiGroup_exports,
   UiContext,
   UiOperation,
   UiUnauthorized,

package/js/{chunk-G7IE6BKC.js → chunk-HDTGZWP2.js}

@@ -2,7 +2,7 @@ import {
   adaptMcpTools,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-X7SFGU4Q.js";
+} from "./chunk-RN2MXB4R.js";
 import {
   accountProviderError,
   httpProviderError
@@ -11,7 +11,7 @@ import {
   McpError,
   McpToolsOptions,
   defaultMcpClientLimits
-} from "./chunk-IHQ4ML7K.js";
+} from "./chunk-MYYEW3RA.js";
 import {
   ProviderError
 } from "./chunk-W7D7WVSY.js";

package/js/{chunk-KOXMLKTM.js → chunk-J7O55ZV7.js}

@@ -1,20 +1,20 @@
+import {
+  makeCache
+} from "./chunk-D47C7KG5.js";
 import {
   folderSkillsEffect
-} from "./chunk-ZTFQHGEB.js";
+} from "./chunk-FDNTX5QJ.js";
 import {
-  CacheEntry,
-  CacheError,
   authorDatabase,
-  cacheLimits,
   isApp,
   toEffectApp,
   unavailableStorage
-} from "./chunk-RBAC33PQ.js";
+} from "./chunk-JN55AYQH.js";
 import {
   fromPromise,
   nativeOperation,
   toPromise
-} from "./chunk-PZ36XMXW.js";
+} from "./chunk-PYUYJRSK.js";
 import {
   parseProviderError
 } from "./chunk-ZJWDMTE3.js";
@@ -62,7 +62,10 @@ import {
   defaultWebhookTransportLimits,
   maxInputProblems,
   workflowDurationMillis
-} from "./chunk-IHQ4ML7K.js";
+} from "./chunk-MYYEW3RA.js";
+import {
+  CacheError
+} from "./chunk-LGIYBDWA.js";
 import {
   AppSkills,
   SkillFile,
@@ -79,7 +82,7 @@ import {
   decoderOf,
   importedJsonSchema,
   jsonSchemaDecoder
-} from "./chunk-2HHMABB6.js";
+} from "./chunk-WFSQXYUT.js";
 import {
   JsonObject,
   JsonValue
@@ -87,7 +90,6 @@ import {
 import {
   Cause_exports,
   Clock_exports,
-  Duration_exports,
   Effect_exports,
   Encoding_exports,
   Match_exports,
@@ -452,144 +454,14 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
   );
 });
 
-// ../app-cache/src/index.ts
-var canonical = (value) => {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-  if (value !== null && typeof value === "object")
-    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
-  return JSON.stringify(value);
-};
-var cacheKey = (key) => Effect_exports.gen(function* () {
-  const parsed = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(key).pipe(
-    Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
-  );
-  const bytes = new TextEncoder().encode(canonical(parsed));
-  if (bytes.byteLength > cacheLimits.keyBytes)
-    return yield* new CacheError({ reason: "capacity" });
-  const hash = yield* Effect_exports.tryPromise({
-    try: () => crypto.subtle.digest("SHA-256", bytes),
-    catch: () => new CacheError({ reason: "invalid" })
-  });
-  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-});
-var makeCache = (transport, background, scope = "shared") => {
-  const keyOf = (key) => cacheKey([scope, key]);
-  const readKeys = (keys) => transport({ operation: "read", keys }).pipe(
-    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))),
-    Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
-  );
-  const durations = (freshFor, staleFor = 0) => Effect_exports.try({
-    try: () => {
-      const fresh = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor));
-      const stale = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor));
-      if (![fresh, stale].every((value) => Number.isFinite(value) && value >= 0) || fresh + stale > cacheLimits.retentionMs)
-        throw new CacheError({ reason: "invalid" });
-      return { fresh, stale };
-    },
-    catch: () => new CacheError({ reason: "invalid" })
-  });
-  const get = (options, refresh) => Effect_exports.gen(function* () {
-    const key = yield* keyOf(options.key);
-    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* () {
-      const value = yield* options.load.pipe(Effect_exports.flatMap(decode));
-      const json = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(value).pipe(
-        Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
-      );
-      const now = yield* Clock_exports.currentTimeMillis;
-      const published = yield* transport({
-        operation: "publish",
-        key,
-        lease,
-        entry: {
-          value: json,
-          version: crypto.randomUUID(),
-          freshUntil: now + fresh,
-          staleUntil: now + fresh + stale
-        }
-      });
-      if (published !== true) return yield* new CacheError({ reason: "unavailable" });
-      return value;
-    }).pipe(
-      Effect_exports.withSpan("app.cache.load"),
-      Effect_exports.timeout(cacheLimits.loadTimeoutMs),
-      Effect_exports.ensuring(
-        transport({ operation: "release", key, lease }).pipe(Effect_exports.catch(() => Effect_exports.void))
-      )
-    );
-    const deadline = (yield* Clock_exports.currentTimeMillis) + cacheLimits.leaseMs;
-    let initialVersion;
-    while (true) {
-      const entry = (yield* readKeys([key]))[0] ?? null;
-      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 && now < entry.freshUntil)) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
-        return yield* decode(entry.value);
-      }
-      const lease = yield* transport({
-        operation: "claim",
-        key,
-        version: entry?.version ?? null
-      }).pipe(Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.NullOr(Schema_exports.String))));
-      if (!refresh && entry !== null && now < entry.staleUntil) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
-        if (lease !== null) yield* background(load(lease).pipe(Effect_exports.asVoid));
-        return yield* decode(entry.value);
-      }
-      if (lease !== null) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "miss");
-        return yield* load(lease);
-      }
-      if (now >= deadline) return yield* new CacheError({ reason: "timeout" });
-      yield* Effect_exports.sleep("100 millis");
-    }
-  }).pipe(Effect_exports.withSpan("app.cache.get"));
-  return {
-    /** Read arbitrary retained JSON entries without initiating a refresh. Missing and null are distinct. */
-    read: (keys) => Effect_exports.forEach(keys, keyOf).pipe(Effect_exports.flatMap(readKeys)),
-    /** Publish bounded immutable parts before publishing the manifest that references them. */
-    write: (entries, retention) => Effect_exports.gen(function* () {
-      const { fresh } = yield* durations(retention);
-      const now = yield* Clock_exports.currentTimeMillis;
-      const values = yield* Effect_exports.forEach(
-        entries,
-        ({ key, value }) => Effect_exports.gen(function* () {
-          return {
-            key: yield* keyOf(key),
-            entry: {
-              value,
-              version: crypto.randomUUID(),
-              freshUntil: now + fresh,
-              staleUntil: now + fresh
-            }
-          };
-        })
-      );
-      yield* transport({ operation: "write", entries: values });
-    }),
-    /** Revoke retained data and any loader's right to publish its in-flight result. */
-    invalidate: (key) => keyOf(key).pipe(
-      Effect_exports.flatMap((key2) => transport({ operation: "invalidate", key: key2 })),
-      Effect_exports.asVoid
-    ),
-    /** Read fresh data, refresh stale data in the background, or wait for the lease owner. */
-    get: (options) => get(options, false),
-    /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
-    revalidate: (options) => get(options, true)
-  };
-};
-
 // 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) => {
+var authorCache = (host, accounts, signal, deadline) => {
   const scoped = (scope, callerSignal = signal) => {
-    const cache = makeCache(host.transport, host.background, scope);
+    const cache = makeCache(host.transport, host.background, scope, deadline);
     const load = (method, options) => cache[method]({
       key: options.key,
       schema: decoderOf(options.schema),
@@ -641,7 +513,7 @@ var authorCache = (host, accounts, signal) => {
         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, fields: bound.fields },
+          { account: bound.id, method: bound.method, generation: bound.generation },
           callerSignal
         );
       }
@@ -728,10 +600,10 @@ function requirements(slots, database) {
     }).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
   });
 }
-function canonical2(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical2).join(",")}]`;
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
   if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical2(item)}`).join(",")}}`;
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -760,7 +632,7 @@ function bindAccounts(slots, declarations, context) {
         for (const account of accounts) {
           if (ids.has(account.id)) return yield* Effect_exports.fail(new HostAccountsInvalid());
           ids.add(account.id);
-          if (canonical2(account.provider) !== canonical2(requirement.definition) || !Object.hasOwn(provider.auth, account.method))
+          if (canonical(account.provider) !== canonical(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());
@@ -855,7 +727,8 @@ function dispatch(app, request, context, signal) {
         cache: authorCache(
           context.cache ?? unavailableCache,
           Redacted_exports.value(context.accounts),
-          invocationSignal
+          invocationSignal,
+          deadline
         ),
         files,
         ...yield* bindAccounts(native.accounts, declared, context).pipe(
@@ -1283,6 +1156,5 @@ var createAppHandler = (app) => (request, context) => Effect_exports.gen(functio
 export {
   prepareElicitation,
   ApprovalDecision,
-  cacheKey,
   createAppHandler
 };

package/js/{chunk-RBAC33PQ.js → chunk-JN55AYQH.js}

@@ -5,15 +5,15 @@ import {
 import {
   fromPromise,
   nativeOperation
-} from "./chunk-PZ36XMXW.js";
+} from "./chunk-PYUYJRSK.js";
 import {
   ScheduleTiming
-} from "./chunk-IHQ4ML7K.js";
+} from "./chunk-MYYEW3RA.js";
 import {
   decoderOf,
   isSchema,
   storageFieldOf
-} from "./chunk-2HHMABB6.js";
+} from "./chunk-WFSQXYUT.js";
 import {
   AppStorageUnavailable
 } from "./chunk-FZJOYIZO.js";
@@ -25,55 +25,6 @@ import {
   Schema_exports
 } from "./chunk-FW5HBOIK.js";
 
-// ../app-cache/src/contracts/cache.ts
-var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
-  reason: Schema_exports.Literals(["unavailable", "storage", "invalid", "capacity", "timeout"])
-}) {
-};
-var cacheLimits = {
-  keyBytes: 8192,
-  entryBytes: 2e6,
-  batchBytes: 8e6,
-  batchEntries: 128,
-  totalBytes: 128e6,
-  totalEntries: 1e5,
-  retentionMs: 7 * 24 * 60 * 60 * 1e3,
-  loadTimeoutMs: 9e4,
-  leaseMs: 12e4
-};
-var Key = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/));
-var Time = Schema_exports.Finite.check(Schema_exports.isGreaterThanOrEqualTo(0));
-var CacheEntry = Schema_exports.Struct({
-  value: Schema_exports.Json,
-  version: Schema_exports.String,
-  freshUntil: Time,
-  staleUntil: Time
-});
-var CacheCommand = Schema_exports.Union([
-  Schema_exports.Struct({ operation: Schema_exports.Literal("read"), keys: Schema_exports.Array(Key) }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("claim"),
-    key: Key,
-    version: Schema_exports.NullOr(Schema_exports.String)
-  }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("publish"),
-    key: Key,
-    lease: Schema_exports.String,
-    entry: CacheEntry
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("release"), key: Key, lease: Schema_exports.String }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("write"),
-    entries: Schema_exports.Array(Schema_exports.Struct({ key: Key, entry: CacheEntry }))
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("invalidate"), key: Key })
-]);
-var CacheReply = Schema_exports.Union([
-  Schema_exports.Struct({ ok: Schema_exports.Literal(true), value: Schema_exports.Json }),
-  Schema_exports.Struct({ ok: Schema_exports.Literal(false), error: CacheError })
-]);
-
 // src/implementation/workflows.ts
 var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
 var workflow = (options, run) => ({
@@ -251,11 +202,6 @@ var unavailableStorage = {
 };
 
 export {
-  CacheError,
-  cacheLimits,
-  CacheEntry,
-  CacheCommand,
-  CacheReply,
   workflow,
   isApp,
   toEffectApp,