apps 0.0.1-beta.0 → 0.0.1-beta.10

package/js/chunk-IPI4MFSN.js

@@ -0,0 +1,78 @@
+import {
+  AppSkillMetadata,
+  AppSkillName,
+  AppSkillSource,
+  SkillDefinitionInvalid,
+  SkillFile,
+  SkillFilePath
+} from "./chunk-JU7VHODU.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-CDL5PM2Q.js";
+
+// src/implementation/skill-files.ts
+var skillFromFiles = (input, source = {}) => Effect_exports.gen(function* () {
+  const file = `${source.directory === void 0 ? "" : `${source.directory}/`}SKILL.md`;
+  const invalid = (reason) => new SkillDefinitionInvalid({ file, reason });
+  const files = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(input).pipe(
+    Effect_exports.mapError(() => invalid("files"))
+  );
+  const document = files.find((file2) => file2.path === "SKILL.md");
+  if (document === void 0) return yield* invalid("missing-document");
+  const match = /^\uFEFF?---[ \t]*\r?\n([\s\S]*?)\r?\n---(?:[ \t]*\r?\n|[ \t]*$)/.exec(
+    document.content
+  );
+  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);
+      if (yaml.errors.length) throw yaml.errors[0];
+      return yaml.toJS();
+    },
+    catch: () => invalid("frontmatter")
+  });
+  const metadata = yield* Schema_exports.decodeUnknownEffect(AppSkillMetadata)(value).pipe(
+    Effect_exports.mapError(() => invalid("metadata"))
+  );
+  if (source.name !== void 0 && metadata.name !== source.name)
+    return yield* invalid("name-mismatch");
+  return yield* Schema_exports.decodeUnknownEffect(AppSkillSource)({ ...metadata, files }).pipe(
+    Effect_exports.mapError(() => invalid("files"))
+  );
+});
+var folderSkillsEffect = (options) => Effect_exports.gen(function* () {
+  const path = options.path ?? "skills";
+  if (!Schema_exports.is(SkillFilePath)(path))
+    return yield* new SkillDefinitionInvalid({ file: "SKILL.md", reason: "directory" });
+  const files = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(options.files).pipe(
+    Effect_exports.mapError(() => new SkillDefinitionInvalid({ file: path, reason: "files" }))
+  );
+  const prefix = `${path}/`;
+  const directories = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.path.startsWith(prefix)) continue;
+    const [name, ...relative] = file.path.slice(prefix.length).split("/");
+    if (relative.length === 0) continue;
+    if (name === void 0 || !Schema_exports.is(AppSkillName)(name))
+      return yield* new SkillDefinitionInvalid({ file: file.path, reason: "directory" });
+    const resource = { path: relative.join("/"), content: file.content };
+    const existing = directories.get(name);
+    if (existing === void 0) directories.set(name, [resource]);
+    else existing.push(resource);
+  }
+  return yield* Effect_exports.forEach(
+    [...directories].sort(([a], [b]) => a.localeCompare(b)),
+    ([name, files2]) => skillFromFiles(
+      files2.sort((a, b) => a.path.localeCompare(b.path)),
+      { name, directory: `${path}/${name}` }
+    )
+  );
+});
+
+export {
+  skillFromFiles,
+  folderSkillsEffect
+};

package/js/chunk-JU7VHODU.js

@@ -0,0 +1,104 @@
+import {
+  Schema_exports
+} from "./chunk-CDL5PM2Q.js";
+
+// src/contracts/skills.ts
+var SkillFilePath = Schema_exports.NonEmptyString.check(
+  Schema_exports.makeFilter(
+    (path) => !path.startsWith("/") && !path.includes("\\") && !path.includes("\0") && path.split("/").every((part) => part !== "" && part !== "." && part !== "..")
+  )
+);
+var SkillFile = Schema_exports.Struct({ path: SkillFilePath, content: Schema_exports.String });
+var skillFormatLimits = {
+  nameCharacters: 64,
+  descriptionCharacters: 1024,
+  compatibilityCharacters: 500
+};
+var AppSkillName = Schema_exports.NonEmptyString.check(
+  Schema_exports.makeFilter(
+    (value) => value === value.toLowerCase() && /^[\p{L}\p{N}]+(?:-[\p{L}\p{N}]+)*$/u.test(value) && [...value].length <= skillFormatLimits.nameCharacters
+  )
+);
+var AppSkillMetadata = Schema_exports.Struct({
+  name: AppSkillName,
+  description: Schema_exports.String.check(
+    Schema_exports.makeFilter(
+      (value) => value.trim().length > 0 && [...value].length <= skillFormatLimits.descriptionCharacters
+    )
+  ),
+  license: Schema_exports.optionalKey(Schema_exports.String),
+  compatibility: Schema_exports.optionalKey(
+    Schema_exports.String.check(
+      Schema_exports.makeFilter(
+        (value) => value.trim().length > 0 && [...value].length <= skillFormatLimits.compatibilityCharacters
+      )
+    )
+  ),
+  metadata: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
+  "allowed-tools": Schema_exports.optionalKey(Schema_exports.String)
+});
+var AppSkillSource = Schema_exports.Struct({
+  ...AppSkillMetadata.fields,
+  files: Schema_exports.Array(SkillFile).check(
+    Schema_exports.makeFilter(
+      (files) => files.some((file) => file.path === "SKILL.md") && new Set(files.map((file) => file.path)).size === files.length
+    )
+  )
+});
+var SkillDefinitionInvalid = class extends Schema_exports.TaggedError()(
+  "SkillDefinitionInvalid",
+  {
+    file: SkillFilePath,
+    reason: Schema_exports.Literals([
+      "files",
+      "directory",
+      "missing-document",
+      "frontmatter",
+      "metadata",
+      "name-mismatch"
+    ])
+  },
+  { httpApiStatus: 400 }
+) {
+};
+var AppSkills = Schema_exports.Array(AppSkillSource).check(
+  Schema_exports.makeFilter((skills) => new Set(skills.map((skill) => skill.name)).size === skills.length)
+);
+var SkillServiceName = Schema_exports.String.check(
+  Schema_exports.isPattern(/^[A-Za-z0-9](?:[A-Za-z0-9 .-]{0,98}[A-Za-z0-9])?$/)
+);
+var SkillLoadFailed = class extends Schema_exports.TaggedError()("SkillLoadFailed", {
+  reason: Schema_exports.Literals([
+    "source",
+    "request",
+    "rate_limited",
+    "document",
+    "limit",
+    "changed",
+    "encoding"
+  ]),
+  // Error instances read an omitted message as "", so an empty message means none was given.
+  message: Schema_exports.optional(Schema_exports.String.check(Schema_exports.isMaxLength(500))),
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 })))
+}) {
+};
+var skillLoadLimits = {
+  files: 1e3,
+  fileBytes: 2e6,
+  totalBytes: 2e7,
+  concurrency: 8
+};
+
+export {
+  SkillFilePath,
+  SkillFile,
+  skillFormatLimits,
+  AppSkillName,
+  AppSkillMetadata,
+  AppSkillSource,
+  SkillDefinitionInvalid,
+  AppSkills,
+  SkillServiceName,
+  SkillLoadFailed,
+  skillLoadLimits
+};

package/js/chunk-KUMBKVJD.js

@@ -0,0 +1,39 @@
+import {
+  appSignInCallbackPath
+} from "./chunk-VFZKSM3T.js";
+import {
+  HttpServerResponse_exports
+} from "./chunk-UK573G7W.js";
+
+// src/implementation/ui-auth.ts
+var appPrivateHeaders = {
+  "cache-control": "no-store",
+  "referrer-policy": "no-referrer",
+  "x-content-type-options": "nosniff",
+  "content-security-policy": "frame-ancestors 'none'"
+};
+var appRedirect = (url) => HttpServerResponse_exports.redirect(url, { status: 302, headers: appPrivateHeaders });
+var appSignInCallback = (origin, request, code) => {
+  const callback = new URL(appSignInCallbackPath, origin);
+  callback.searchParams.set("request", request);
+  callback.searchParams.set("code", code);
+  return callback.href;
+};
+var appSignInFailed = () => HttpServerResponse_exports.text(
+  `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Could not open app</title></head><body><p>Could not sign in to this app. Try opening it again.</p><a href="/">Try again</a></body></html>`,
+  {
+    status: 401,
+    contentType: "text/html",
+    headers: {
+      ...appPrivateHeaders,
+      "content-security-policy": "default-src 'none'; frame-ancestors 'none'; base-uri 'none'"
+    }
+  }
+);
+
+export {
+  appPrivateHeaders,
+  appRedirect,
+  appSignInCallback,
+  appSignInFailed
+};

package/js/{chunk-YDR4CPJA.js → chunk-M3B3DE4K.js}

@@ -3,7 +3,7 @@ import {
   invalidate,
   layer,
   mutation
-} from "./chunk-D6BKYP2L.js";
+} from "./chunk-PJJ24GU7.js";
 import {
   Boolean,
   Cause,
@@ -158,12 +158,12 @@ import {
   void_2,
   whileLoop,
   zipRight
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-CDL5PM2Q.js";
 import {
   __export
-} from "./chunk-MLKGABMK.js";
+} from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
 var AsyncResult_exports = {};
 __export(AsyncResult_exports, {
   Schema: () => Schema,
@@ -600,7 +600,7 @@ var Schema = (options) => {
   });
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
 var AtomRegistry_exports = {};
 __export(AtomRegistry_exports, {
   AtomRegistry: () => AtomRegistry,
@@ -1340,7 +1340,7 @@ function batchRebuildNode(node) {
   }
 }
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
 var Atom_exports = {};
 __export(Atom_exports, {
   Interrupt: () => Interrupt,
@@ -1400,7 +1400,7 @@ __export(Atom_exports, {
   writable: () => writable
 });
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
 var ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
 var KeyValueStoreError = class extends (/* @__PURE__ */ TaggedError("KeyValueStoreError")) {
   /**
@@ -1442,7 +1442,7 @@ var toSchemaStore = (self, schema) => {
   };
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
 var TypeId3 = "~effect/reactivity/Atom";
 var isAtom = (u) => hasProperty(u, TypeId3);
 var WritableTypeId = "~effect/reactivity/Atom/Writable";

package/js/chunk-MKWZPDR6.js

@@ -0,0 +1,63 @@
+import {
+  ProviderError
+} from "./chunk-R3EV5FTO.js";
+import {
+  AccountId
+} from "./chunk-27F7W2LG.js";
+import {
+  Option_exports,
+  Schema_exports
+} from "./chunk-CDL5PM2Q.js";
+
+// src/implementation/provider-error.ts
+function parseProviderError(error) {
+  return Schema_exports.decodeUnknownOption(ProviderError)(error).pipe(
+    Option_exports.map(({ reason, status, accountId }) => new ProviderError({ reason, status, accountId }))
+  );
+}
+function httpProviderError(status, headers = {}) {
+  if (status >= 500 && status <= 599) return new ProviderError({ reason: "unavailable", status });
+  if (status === 401) return new ProviderError({ reason: "unauthorized", status });
+  if (status === 429) return new ProviderError({ reason: "rate_limited", status });
+  if (status !== 403) return void 0;
+  const retry = headers["retry-after"];
+  if (headers["x-ratelimit-remaining"] === "0" || retry !== void 0 && (/^\d+$/.test(retry) || Number.isFinite(Date.parse(retry))))
+    return new ProviderError({ reason: "rate_limited", status });
+  if (/\bBearer\b.*\berror="insufficient_scope"/i.test(headers["www-authenticate"] ?? ""))
+    return new ProviderError({ reason: "forbidden", status });
+  return new ProviderError({ reason: "rejected", status });
+}
+function accountProviderError(error, accountId) {
+  const parsed = parseProviderError(error);
+  const account = Schema_exports.decodeUnknownOption(AccountId)(accountId);
+  if (Option_exports.isNone(parsed) || Option_exports.isNone(account)) return error;
+  return new ProviderError({
+    reason: parsed.value.reason,
+    status: parsed.value.status,
+    accountId: account.value
+  });
+}
+function graphqlProviderError(errors, status) {
+  const codes = errors.flatMap((error) => {
+    const parsed = Schema_exports.decodeUnknownOption(
+      Schema_exports.Struct({
+        type: Schema_exports.optional(Schema_exports.String),
+        extensions: Schema_exports.optional(Schema_exports.Struct({ code: Schema_exports.optional(Schema_exports.String) }))
+      })
+    )(error);
+    return Option_exports.isSome(parsed) ? [parsed.value.type, parsed.value.extensions?.code] : [];
+  });
+  if (codes.includes("RATE_LIMITED") || codes.includes("TOO_MANY_REQUESTS"))
+    return new ProviderError({ reason: "rate_limited", status });
+  if (codes.includes("UNAUTHENTICATED"))
+    return new ProviderError({ reason: "unauthorized", status });
+  if (codes.includes("FORBIDDEN")) return new ProviderError({ reason: "forbidden", status });
+  return void 0;
+}
+
+export {
+  parseProviderError,
+  httpProviderError,
+  accountProviderError,
+  graphqlProviderError
+};

package/js/{chunk-7JXHF5IF.js → chunk-N7YDVXYJ.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // ../app-data/src/contracts/database.ts
 var DataName = Schema_exports.String.check(
@@ -113,6 +113,51 @@ var defaultDatabaseLimits = {
   valueBytes: 64 * 1024,
   indexBytes: 2048
 };
+var DatabaseLimit = Schema_exports.Literals([
+  "scanCalls",
+  "directGets",
+  "rowsRead",
+  "rowsReturned",
+  "pageSize",
+  "bytesRead",
+  "writes",
+  "valueBytes"
+]);
+var count = (value) => value.toLocaleString("en-US");
+var limitMessages = {
+  scanCalls: (maximum, requested) => `This invocation made ${count(requested)} index queries; the limit is ${count(maximum)}. Each first(), take(), collect(), count() or paginate() call on withIndex(...) counts once. Read related rows with one take() or paginate() over a shared index prefix instead of one first() per item, use get(id) for known IDs, or split the work across workflow steps.`,
+  directGets: (maximum, requested) => `This invocation made ${count(requested)} get(id) calls, including those made by update and delete; the limit is ${count(maximum)}. Split the work across workflow steps or mutations.`,
+  rowsRead: (maximum, requested) => `This invocation scanned ${count(requested)} rows; the limit is ${count(maximum)}. Narrow the index range, or page with paginate() across calls or workflow steps.`,
+  rowsReturned: (maximum, requested) => `This invocation returned ${count(requested)} rows; the limit is ${count(maximum)}. collect() fails rather than truncating. Page with paginate() across calls or workflow steps.`,
+  pageSize: (maximum, requested) => `One call asked for ${count(requested)} rows; take(n) and paginate({ numItems }) accept at most ${count(maximum)}. Page with paginate() across calls or workflow steps.`,
+  bytesRead: (maximum, requested) => `This invocation read ${count(requested)} bytes; the limit is ${count(maximum)}. Read fewer or smaller rows per call, or page with paginate() across calls or workflow steps.`,
+  writes: (maximum, requested) => `This mutation made ${count(requested)} writes; the limit is ${count(maximum)}. Split large ingests into batches, one batch per mutation or workflow step.`,
+  valueBytes: (maximum, requested) => `A row encodes to ${count(requested)} bytes; each row may use at most ${count(maximum)}. Store large content outside the row or split it across rows.`
+};
+var DatabaseLimitExceeded = class extends Schema_exports.TaggedError()(
+  "DatabaseLimitExceeded",
+  {
+    limit: DatabaseLimit,
+    maximum: Schema_exports.Int,
+    requested: Schema_exports.Int
+  }
+) {
+  get message() {
+    return limitMessages[this.limit](this.maximum, this.requested);
+  }
+};
+var reservedFieldNames = ["id", "createdAt", "updatedAt"];
+var DatabaseFieldReserved = class extends Schema_exports.TaggedError()(
+  "DatabaseFieldReserved",
+  {
+    table: Schema_exports.String,
+    field: Schema_exports.Literals(reservedFieldNames)
+  }
+) {
+  get message() {
+    return `Table "${this.table}" declares "${this.field}", which is reserved: the host adds id, createdAt and updatedAt to every row. Rename the field, or use the row's own ${this.field}.`;
+  }
+};
 var DatabaseRuntimeLimits = Schema_exports.Struct({
   maxCursorChars: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
   connectionCacheCapacity: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
@@ -134,5 +179,8 @@ export {
   AppDatabaseError,
   DatabaseLimits,
   defaultDatabaseLimits,
+  DatabaseLimitExceeded,
+  reservedFieldNames,
+  DatabaseFieldReserved,
   defaultDatabaseRuntimeLimits
 };

package/js/chunk-NKLWZJLE.js

@@ -0,0 +1,172 @@
+import {
+  CacheAcquired,
+  CacheEntry,
+  CacheError,
+  cacheLimits
+} from "./chunk-R3EV5FTO.js";
+import {
+  Clock_exports,
+  Duration_exports,
+  Effect_exports,
+  Exit_exports,
+  Schema_exports
+} from "./chunk-CDL5PM2Q.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
+};