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

package/js/{chunk-Z5M2LQOZ.js → chunk-OY47QPQY.js}

@@ -1,48 +1,20 @@
+import {
+  fromPromise
+} from "./chunk-W6XCQAXP.js";
 import {
   HostedTool,
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-WLE7WX2U.js";
+} from "./chunk-NG56RPCA.js";
 import {
-  decoderOf
-} from "./chunk-5T57N25Q.js";
+  decoderOf,
+  schemaArgument
+} from "./chunk-KGCTYL2S.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/implementation/authoring.ts
-var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
-var fromPromise = (callback) => (...args) => {
-  if (NativeCallback in callback) {
-    const native = callback[NativeCallback];
-    return native(...args);
-  }
-  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error });
-};
-var toPromise = (operation, signal) => {
-  const native = (...args) => Effect_exports.suspend(() => {
-    if (signal === void 0) return operation(...args);
-    if (signal.aborted) return Effect_exports.interrupt;
-    const cancelled = Effect_exports.callback((resume) => {
-      if (signal.aborted) {
-        resume(Effect_exports.interrupt);
-        return;
-      }
-      const abort = () => resume(Effect_exports.interrupt);
-      signal.addEventListener("abort", abort, { once: true });
-      return Effect_exports.sync(() => signal.removeEventListener("abort", abort));
-    });
-    return Effect_exports.raceFirst(
-      cancelled,
-      Effect_exports.suspend(() => operation(...args))
-    );
-  });
-  return Object.assign((...args) => Effect_exports.runPromise(native(...args)), {
-    [NativeCallback]: native
-  });
-};
+} from "./chunk-IFJU5SYQ.js";
 
 // src/implementation/operations.ts
 var NativeOperation = /* @__PURE__ */ Symbol("apps.Operation");
@@ -64,28 +36,30 @@ var operationOptions = (options) => {
     ...options._meta === void 0 ? {} : { _meta: options._meta },
     input: decoderOf(options.input),
     ...approval === void 0 ? {} : {
-      approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
+      approval: (context) => fromPromise(async () => approval(context), "approval")()
     }
   };
 };
+var approvedOperation = (operation, approval) => {
+  const copy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(operation));
+  return Object.defineProperty(copy, "approval", {
+    enumerable: true,
+    value: (context) => fromPromise(async () => approval(context), "approval")()
+  });
+};
 var withApproval = (operation, approval) => ({
   ...operation,
-  [NativeOperation]: {
-    ...operation[NativeOperation],
-    approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
-  }
+  [NativeOperation]: approvedOperation(operation[NativeOperation], approval)
 });
+var toolAnnotations = (operation) => nativeOperation(operation)?.annotations;
 var make = (kind, options, run) => operationDeclaration({
-  ...operationOptions(options),
+  ...operationOptions({ ...options, input: schemaArgument(options.input, `The ${kind} input`) }),
   kind,
   // The host always validates JSON serialization, even without a stronger output declaration.
-  ...options.output === void 0 ? {} : { output: decoderOf(options.output) },
-  run: (context, input) => Effect_exports.tryPromise({
-    // SAFETY: defineApp checks the handler context against its requirements.
-    // The host validates account bindings and creates the matching storage facade.
-    try: () => run(context, input),
-    catch: (error) => error
-  })
+  ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, `The ${kind} output`)) },
+  // SAFETY: defineApp checks the handler context against its requirements.
+  // The host validates account bindings and creates the matching storage facade.
+  run: (context, input) => fromPromise(run, "handler")(context, input)
 });
 var query = (options, run) => make("query", options, run);
 var mutation = (options, run) => make("mutation", options, run);
@@ -133,14 +107,14 @@ var dynamicRouter = (source) => {
   return routerDeclaration({
     kind: "dynamic",
     ...meta === void 0 ? {} : {
-      meta: () => fromPromise(async () => meta())().pipe(
+      meta: () => fromPromise(async () => meta(), "router")().pipe(
         Effect_exports.flatMap((options) => Schema_exports.decodeUnknownEffect(RouterMeta)(options))
       )
     },
-    list: () => fromPromise(async () => source.list())().pipe(
+    list: () => fromPromise(async () => source.list(), "router")().pipe(
       Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedTool)))
     ),
-    resolve: (name) => fromPromise(async () => source.resolve(name))().pipe(
+    resolve: (name) => fromPromise(async () => source.resolve(name), "router")().pipe(
       Effect_exports.map((value) => {
         if (value === void 0) return void 0;
         const operation = nativeOperation(value);
@@ -189,13 +163,50 @@ var declaredOperations = (root, path = "") => Object.entries(root?.children ?? {
       return [];
   }
 });
+var withApprovals = (source, policy) => {
+  const native = nativeRouter(source);
+  if (native === void 0) throw new Error("withApprovals expects a router");
+  const operation = (node, name) => {
+    const approval = policy(operationDeclaration(node), name);
+    return approval === void 0 ? node : approvedOperation(node, approval);
+  };
+  const child = (node, name) => {
+    switch (node.kind) {
+      case "query":
+      case "mutation":
+        return operation(node, name);
+      case "router":
+      case "dynamic":
+        return walk(node, name);
+    }
+  };
+  const walk = (node, path) => node.kind === "dynamic" ? {
+    ...node,
+    resolve: (name) => node.resolve(name).pipe(
+      Effect_exports.flatMap(
+        (resolved) => resolved === void 0 ? Effect_exports.succeed(void 0) : Effect_exports.try({
+          try: () => operation(resolved, joinPath(path, name)),
+          catch: (error) => error
+        })
+      )
+    )
+  } : {
+    ...node,
+    children: Object.fromEntries(
+      Object.entries(node.children).map(([key, value]) => [
+        key,
+        child(value, joinPath(path, key))
+      ])
+    )
+  };
+  return routerDeclaration(walk(native, ""));
+};
 
 export {
-  fromPromise,
-  toPromise,
   operationDeclaration,
   nativeOperation,
   withApproval,
+  toolAnnotations,
   query,
   mutation,
   routerDeclaration,
@@ -205,5 +216,6 @@ export {
   dynamicRouter,
   joinPath,
   locate,
-  declaredOperations
+  declaredOperations,
+  withApprovals
 };

package/js/{chunk-57RKNWL2.js → chunk-PD6I2SDG.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-UK573G7W.js";
+} from "./chunk-EOPQ727L.js";
 import {
   Reference,
   Service,
@@ -13,16 +13,16 @@ import {
   getOrUndefined2 as getOrUndefined,
   map3 as map,
   merge3 as merge,
-  remove3 as remove,
+  remove2 as remove,
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/http/FetchHttpClient.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http/FetchHttpClient.js
 var FetchHttpClient_exports = {};
 __export(FetchHttpClient_exports, {
   Fetch: () => Fetch,

package/js/chunk-PL5KOEZD.js

@@ -0,0 +1,334 @@
+import {
+  appInvocationFetch
+} from "./chunk-I6Q7ZPKJ.js";
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-W6XCQAXP.js";
+import {
+  CacheAcquired,
+  CacheEntry,
+  CacheError,
+  cacheLimits
+} from "./chunk-Q4IZAUIF.js";
+import {
+  decoderOf
+} from "./chunk-KGCTYL2S.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 = 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,
+          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
+};