apps 0.0.1-beta.8 → 0.0.1-beta.81

package/types/utils/src/connection-failure.d.ts

@@ -0,0 +1,33 @@
+/** Requests the browser could not complete because no response reached it. */
+import { Cause } from "effect";
+import { HttpClientError } from "effect/http";
+import { UserFacingError } from "./user-facing-error.js";
+/**
+ * Fetch rejects with a `TypeError` when no response arrives: the device is offline, the page
+ * navigated away first, the connection was reset before a response, or the browser blocked the
+ * request. The server may still have completed the request and records its own outcome. Failures Executor constructs itself, such as a batch reply
+ * that ended without an answer, carry no such cause and stay unexpected.
+ */
+export declare const isConnectionFailure: (error: unknown) => error is HttpClientError.HttpClientError;
+/** Typed API clients may surface a lost connection as a failure or, after narrowing, a defect. */
+export declare const hasConnectionFailure: (cause: Cause.Cause<unknown>) => boolean;
+/** The browser could not reach Executor. Nothing on the server needs fixing. */
+export declare const ConnectionFailed: import("effect/Schema").Class<{} & UserFacingError & {
+    readonly _tag: "ConnectionFailed";
+}, Omit<import("effect/Schema").TaggedStruct<"ConnectionFailed", {
+    readonly message: typeof import("./api-error.js").MessageField;
+    readonly recovery: import("effect/Schema").decodeTo<import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly action: import("effect/Schema").String;
+        readonly instructions: import("effect/Schema").String;
+    }>>, import("effect/Schema").Struct<{
+        readonly action: import("effect/Schema").String;
+        readonly instructions: import("effect/Schema").String;
+    }>, never, never>;
+}>, "~type.make.in"> & {
+    readonly "~type.make.in": {
+        readonly _tag?: "ConnectionFailed";
+    };
+}, UserFacingError>;
+export type ConnectionFailed = typeof ConnectionFailed.Type;
+/** What to show for a failure no contract declares: a lost connection, or an unexpected error. */
+export declare const undeclaredError: (cause: Cause.Cause<unknown>) => UserFacingError;

package/types/utils/src/recorded-message.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The fixed sentence traces and error reports record for a tagged error, beside its tag. Telemetry
+ * records no other text from a tagged error: one that declares no sentence is recorded by its tag
+ * alone (`@executor-js/telemetry/recorded-failure`). Declare one from fixed text and closed fields
+ * only, never from a value the caller supplied (a slug, a name, a tool name, an argument's key),
+ * an app's own text or a service's reply. That text still reaches the caller the error is for.
+ * `ApiError` and `UserFacingError` declare a fixed message for you; a message derived from fields
+ * declares `recorded`.
+ */
+export declare const RecordedMessage: unique symbol;
+/** The fixed sentence an error declares for telemetry, if it declares one. */
+export declare const recordedMessage: (error: unknown) => string | undefined;
+/**
+ * Declare a recorded message on one error that Executor did not define the text of, such as an
+ * error decoded from an app's reply. An error class's own declaration is kept. The error's fields
+ * and wire encoding are unchanged.
+ */
+export declare const recordAs: <E>(error: E, message: string) => E;

package/types/utils/src/user-facing-error.d.ts

@@ -0,0 +1,83 @@
+import { Schema, type Cause } from "effect";
+import "effect/http-api";
+import { MessageField } from "./api-error.js";
+/** Curated explanation and recovery. Never include raw diagnostics, credentials, or form values. */
+export interface ErrorPresentation {
+    readonly title: string;
+    readonly description: string;
+    readonly recovery: {
+        readonly action: string;
+        readonly instructions: string;
+    };
+    /** Repeating the failed operation can help. Configuration changes are not retries. */
+    readonly retryable?: boolean;
+    /** False when the user's agent cannot act on the fix prompt, so hosts do not offer it. */
+    readonly agentFixable?: boolean;
+    /** One safe value the user needs for recovery, such as a URL to send to the service. */
+    readonly detail?: {
+        readonly label: string;
+        readonly value: string;
+    };
+    /**
+     * Present only when the Executor team must fix the problem. Safe evidence for a public
+     * report: fixed codes and statuses, never user data, URLs, or upstream text.
+     */
+    readonly report?: string;
+}
+type PresentationProperties = Required<Omit<ErrorPresentation, "detail" | "report">> & {
+    readonly detail: ErrorPresentation["detail"];
+    readonly report: ErrorPresentation["report"];
+    readonly code: string;
+    readonly fixPrompt: string;
+};
+/** A yieldable error that owns its safe user explanation and agent recovery task. */
+export interface UserFacingError extends Cause.YieldableError, PresentationProperties {
+    readonly _tag: string;
+}
+type Header<Tag extends string> = {
+    readonly tag: Tag;
+    readonly status: number;
+};
+type Definition<Tag extends string, Fields extends Schema.Struct.Fields> = Header<Tag> & {
+    readonly fields: Fields & {
+        readonly [Key in keyof PresentationProperties | "_tag" | "message"]?: never;
+    };
+    /**
+     * What traces and error reports record beside the tag. A fixed description is recorded as is; a
+     * presentation derived from fields is recorded only through this, from fixed text and closed
+     * fields, never a value the caller chose, an app's text or a service's reply. Without it the
+     * error is recorded by its tag alone.
+     */
+    readonly recorded?: (fields: Schema.Struct.Type<Fields>) => string;
+} & (ErrorPresentation | {
+    readonly presentation: (fields: Schema.Struct.Type<Fields>) => ErrorPresentation;
+});
+declare const RecoveryField: Schema.decodeTo<Schema.optionalKey<Schema.Struct<{
+    readonly action: Schema.String;
+    readonly instructions: Schema.String;
+}>>, Schema.Struct<{
+    readonly action: Schema.String;
+    readonly instructions: Schema.String;
+}>, never, never>;
+type DerivedFields = {
+    readonly message: typeof MessageField;
+    readonly recovery: typeof RecoveryField;
+};
+type ErrorFields<Tag extends string, Fields extends Schema.Struct.Fields> = Omit<Schema.TaggedStruct<Tag, Fields & DerivedFields>, "~type.make.in"> & {
+    readonly "~type.make.in": Schema.TaggedStruct<Tag, Fields>["~type.make.in"];
+};
+type ErrorClass<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<Schema.Struct.Type<Fields> & UserFacingError & {
+    readonly _tag: Tag;
+}, ErrorFields<Tag, Fields>, UserFacingError>;
+/** Define a schema-backed error with no payload. Its tag becomes its public error code. */
+declare function define<const Tag extends string>(definition: Header<Tag> & ErrorPresentation): ErrorClass<Tag, {}>;
+/** Define a schema-backed error whose safe presentation can depend on its parsed fields. */
+declare function define<const Tag extends string, const Fields extends Schema.Struct.Fields>(definition: Definition<Tag, Fields>): ErrorClass<Tag, Fields>;
+/** Define the schema, error constructor, user copy, and agent recovery together. */
+export declare const UserFacingError: {
+    define: typeof define;
+    is: (value: unknown) => value is UserFacingError;
+};
+/** Defects get a safe explanation without exposing an arbitrary cause. */
+export declare const UnexpectedError: ErrorClass<"UnexpectedError", {}>;
+export {};

package/js/chunk-MKWZPDR6.js

@@ -1,63 +0,0 @@
-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-N7YDVXYJ.js

@@ -1,186 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// ../app-data/src/contracts/database.ts
-var DataName = Schema_exports.String.check(
-  Schema_exports.makeFilter((value) => /^[A-Za-z][A-Za-z0-9_]*$/.test(value) && value.length <= 128)
-);
-var Scalar = Schema_exports.Union([Schema_exports.String, Schema_exports.Finite, Schema_exports.Boolean]);
-var Field = Schema_exports.Struct({
-  kind: Schema_exports.Literals(["string", "number", "boolean", "id", "userId"]),
-  optional: Schema_exports.optional(Schema_exports.Boolean),
-  default: Schema_exports.optional(Scalar),
-  references: Schema_exports.optional(DataName)
-});
-var Index = Schema_exports.Struct({ name: DataName, fields: Schema_exports.NonEmptyArray(DataName) });
-var Table = Schema_exports.Struct({
-  fields: Schema_exports.Record(DataName, Field),
-  indexes: Schema_exports.Array(Index)
-});
-var DatabaseSchema = Schema_exports.Record(DataName, Table);
-var Row = Schema_exports.Record(Schema_exports.String, Scalar);
-var RowMetadata = Schema_exports.Struct({
-  id: Schema_exports.NonEmptyString,
-  createdAt: Schema_exports.String,
-  updatedAt: Schema_exports.String
-});
-var Patch = Schema_exports.Record(DataName, Schema_exports.NullOr(Scalar));
-var RangeClause = Schema_exports.Struct({
-  field: DataName,
-  op: Schema_exports.Literals(["eq", "gt", "gte", "lt", "lte"]),
-  value: Schema_exports.NullOr(Scalar)
-});
-var QueryPlan = Schema_exports.Struct({
-  table: DataName,
-  index: DataName,
-  order: Schema_exports.Literals(["asc", "desc"]),
-  clauses: Schema_exports.Array(RangeClause)
-});
-var QueryTerminal = Schema_exports.Union([
-  Schema_exports.Struct({ kind: Schema_exports.Literal("collect") }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("count") }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("first") }),
-  Schema_exports.Struct({
-    kind: Schema_exports.Literal("take"),
-    count: Schema_exports.Int.check(Schema_exports.isGreaterThanOrEqualTo(0))
-  }),
-  Schema_exports.Struct({
-    kind: Schema_exports.Literal("paginate"),
-    cursor: Schema_exports.NullOr(Schema_exports.String),
-    numItems: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-  })
-]);
-var DatabaseOperation = Schema_exports.Union([
-  Schema_exports.Struct({ kind: Schema_exports.Literal("get"), table: DataName, id: Schema_exports.NonEmptyString }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("insert"), table: DataName, value: Patch }),
-  Schema_exports.Struct({
-    kind: Schema_exports.Literal("update"),
-    table: DataName,
-    id: Schema_exports.NonEmptyString,
-    patch: Patch
-  }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("delete"), table: DataName, id: Schema_exports.NonEmptyString }),
-  Schema_exports.Struct({ kind: Schema_exports.Literal("query"), plan: QueryPlan, terminal: QueryTerminal })
-]);
-var PaginationResult = Schema_exports.Struct({
-  page: Schema_exports.Array(Row),
-  continueCursor: Schema_exports.NullOr(Schema_exports.String),
-  isDone: Schema_exports.Boolean
-});
-var OperationResult = Schema_exports.Union([
-  Row,
-  Schema_exports.Array(Row),
-  PaginationResult,
-  Schema_exports.Boolean,
-  Schema_exports.Finite,
-  Schema_exports.Null
-]);
-var AppDatabaseError = class extends Schema_exports.TaggedError()("AppDatabaseError", {
-  reason: Schema_exports.Literals([
-    "schema",
-    "schema_changed",
-    "table",
-    "index",
-    "range",
-    "value",
-    "readonly",
-    "cursor",
-    "limit",
-    "closed",
-    "storage",
-    "replay"
-  ])
-}) {
-};
-var DatabaseLimits = Schema_exports.Struct({
-  rowsRead: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  rowsReturned: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  bytesRead: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  writes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  scanCalls: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  directGets: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  valueBytes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  indexBytes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultDatabaseLimits = {
-  rowsRead: 5e3,
-  rowsReturned: 1e3,
-  bytesRead: 4 * 1024 * 1024,
-  writes: 1e3,
-  scanCalls: 100,
-  directGets: 1e3,
-  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)),
-  connectionCacheTtlMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultDatabaseRuntimeLimits = DatabaseRuntimeLimits.make({
-  maxCursorChars: 8192,
-  connectionCacheCapacity: 64,
-  connectionCacheTtlMs: 5 * 60 * 1e3
-});
-
-export {
-  DatabaseSchema,
-  Row,
-  RowMetadata,
-  RangeClause,
-  DatabaseOperation,
-  PaginationResult,
-  AppDatabaseError,
-  DatabaseLimits,
-  defaultDatabaseLimits,
-  DatabaseLimitExceeded,
-  reservedFieldNames,
-  DatabaseFieldReserved,
-  defaultDatabaseRuntimeLimits
-};

package/js/chunk-NKLWZJLE.js

@@ -1,172 +0,0 @@
-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
-};