apps 0.0.1-beta.9 → 0.0.1-beta.91

package/js/chunk-7PHHWYV4.js

@@ -0,0 +1,335 @@
+import {
+  appInvocationFetch
+} from "./chunk-YRGL4QEF.js";
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-I5C7FD5Z.js";
+import {
+  CacheAcquired,
+  CacheEntry,
+  CacheError,
+  cacheLimits,
+  scopedSlots
+} from "./chunk-6XQLA5NC.js";
+import {
+  decoderOf
+} from "./chunk-GQ33QSNB.js";
+import {
+  captureTelemetry,
+  owned,
+  ownedBy
+} from "./chunk-QWQM3CLH.js";
+import {
+  Clock_exports,
+  Duration_exports,
+  Effect_exports,
+  Exit_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.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", limit: "keyBytes" });
+  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, leaseWait = (effect) => effect) => {
+  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: () => ({
+      fresh: Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor)),
+      stale: Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor))
+    }),
+    catch: () => new CacheError({ reason: "invalid" })
+  }).pipe(
+    Effect_exports.flatMap(
+      ({ fresh, stale }) => ![fresh, stale].every((value) => Number.isFinite(value) && value >= 0) ? Effect_exports.fail(new CacheError({ reason: "invalid" })) : (
+        // The cache keeps nothing past its retention: a longer lifetime loses staleness first.
+        Effect_exports.succeed({
+          fresh: Math.min(fresh, cacheLimits.retentionMs),
+          stale: Math.max(0, Math.min(stale, cacheLimits.retentionMs - fresh))
+        })
+      )
+    )
+  );
+  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* () {
+      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;
+    const attempt = Effect_exports.gen(function* () {
+      const acquired = yield* transport({
+        operation: "acquire",
+        key,
+        refresh,
+        ...initialVersion === void 0 ? {} : { version: initialVersion },
+        ...reads === void 0 ? {} : { reads }
+      }).pipe(
+        Effect_exports.flatMap(
+          (reply) => Schema_exports.decodeUnknownEffect(CacheAcquired)(reply).pipe(
+            Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
+          )
+        )
+      );
+      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))
+        return { next: "fresh", entry, together };
+      const kept = !refresh && entry !== null && now < entry.staleUntil;
+      if (kept && options.stale !== "revalidate")
+        return { next: "stale", entry, lease, together };
+      if (lease !== null) return { next: "load", lease, kept };
+      if (now >= waitUntil) return { next: "local" };
+      return { next: "wait" };
+    });
+    let decided = yield* attempt;
+    if (decided.next === "wait")
+      decided = yield* Effect_exports.gen(function* () {
+        while (true) {
+          yield* Effect_exports.sleep("100 millis");
+          const next = yield* attempt;
+          if (next.next !== "wait") return next;
+        }
+      }).pipe(leaseWait);
+    switch (decided.next) {
+      case "fresh":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
+        return withReads(yield* decode(decided.entry.value), decided.together);
+      case "stale":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
+        if (decided.lease !== null) yield* background(load(decided.lease).pipe(Effect_exports.asVoid));
+        return withReads(yield* decode(decided.entry.value), decided.together);
+      case "load":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", decided.kept ? "revalidated" : "miss");
+        return loaded(yield* load(decided.lease));
+      case "local":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "local");
+        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 } })
+          )
+        );
+    }
+  }).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 first, with `stale: "revalidate"`),
+     * or wait for the lease owner.
+     */
+    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).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, services = telemetry) => {
+    const cache = makeCache(
+      host.transport,
+      // A refresh handed to the background runs beside the caller, which does not wait on it.
+      (task) => host.background(task.pipe(owned("background", "app.cache.refresh"))),
+      scope,
+      deadline,
+      // Waiting on another caller's load is waiting, not Executor's work.
+      (wait) => wait.pipe(Effect_exports.withSpan("app.cache.lease.wait", ownedBy("lease")))
+    );
+    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) => Effect_exports.all([appInvocationFetch(controller.signal), captureTelemetry]).pipe(
+          Effect_exports.flatMap(
+            ([fetch, loading]) => fromPromise(
+              method(options, "load"),
+              "loader"
+            )({
+              fetch,
+              signal: controller.signal,
+              cache: scoped(scope, controller.signal, loading.context)
+            })
+          )
+        ),
+        (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,
+      services
+    );
+    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 = scopedSlots(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,
+          services
+        );
+      }
+    };
+    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,
+  getWithReads,
+  unavailableCache,
+  authorCache
+};