apps 0.0.1-beta.6 → 0.0.1-beta.60

package/js/{chunk-RFVIONFX.js → chunk-IJ6Y2KFQ.js}

@@ -1,19 +1,35 @@
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-T53665H5.js";
 import {
   CacheError
-} from "./chunk-R3EV5FTO.js";
+} from "./chunk-MWKHKOTL.js";
 import {
   wrap
-} from "./chunk-5T57N25Q.js";
+} from "./chunk-KGCTYL2S.js";
 import {
   JsonObject
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-H2CJWXA3.js";
 import {
+  Deferred_exports,
   Duration_exports,
   Effect_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/implementation/catalog-cache.ts
+var catalogScope = (options, credential, invalid) => {
+  const { account, cache } = options;
+  if (account === void 0)
+    return credential === void 0 ? Effect_exports.succeed(cache) : Effect_exports.fail(invalid("missing-account"));
+  if (cache === void 0) return Effect_exports.succeed(void 0);
+  return Effect_exports.try({
+    try: () => cache.forAccount(account),
+    catch: () => invalid("unselected-account")
+  });
+};
 var schema = (decoder) => wrap(decoder, false);
 var Manifest = Schema_exports.Struct({
   revision: Schema_exports.String,
@@ -21,7 +37,6 @@ var Manifest = Schema_exports.Struct({
   summaries: Schema_exports.Int,
   header: Schema_exports.optionalKey(JsonObject)
 });
-var invoke = (work) => Effect_exports.tryPromise({ try: work, catch: (error) => error });
 var catalogCache = (options) => Effect_exports.gen(function* () {
   const cache = options.cache;
   const key = [...options.prefix, "current"];
@@ -35,14 +50,42 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
   const staleFor = options.staleFor ?? "1 day";
   const retention = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor)) + Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor)) + 3e5;
   const local = yield* Effect_exports.cached(options.load());
+  const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
+    const batches = yield* Effect_exports.forEach(
+      Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
+      (offset) => fromPromise(method(cache2, "readMany"), "cache")(
+        Array.from(
+          { length: Math.min(4, count - offset) },
+          (_, index) => part(revision, kind, offset + index)
+        ),
+        schema(Schema_exports.Array(decoder))
+      ),
+      { concurrency: "unbounded" }
+    );
+    const values = [];
+    for (const page of batches.flat()) {
+      if (page === void 0) return yield* new CacheError({ reason: "unavailable" });
+      values.push(...page);
+    }
+    return values;
+  });
+  const kept = (cache2) => fromPromise(method(cache2, "read"), "cache")(key, schema(Manifest)).pipe(
+    Effect_exports.map(
+      (manifest) => manifest === void 0 ? void 0 : {
+        header: manifest.header,
+        tools: pages(cache2, manifest.revision, "page", manifest.pages, options.schema)
+      }
+    )
+  );
   const refresh = (context) => Effect_exports.gen(function* () {
-    const { tools, header } = yield* options.load(context);
-    const digest = yield* invoke(
-      () => crypto.subtle.digest(
+    const { tools, header } = yield* options.load(context, kept(context.cache));
+    const digest = yield* Effect_exports.tryPromise({
+      try: () => crypto.subtle.digest(
         "SHA-256",
         new TextEncoder().encode(JSON.stringify({ tools, header: header ?? null }))
-      )
-    );
+      ),
+      catch: (error) => error
+    });
     const revision = Array.from(
       new Uint8Array(digest),
       (byte) => byte.toString(16).padStart(2, "0")
@@ -62,7 +105,7 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
       batch = [];
       batchBytes = 0;
       if (!entries.length) return Effect_exports.void;
-      return invoke(() => context.cache.write(entries, retention)).pipe(
+      return fromPromise(method(context.cache, "write"), "cache")(entries, retention).pipe(
         Effect_exports.withSpan("app.cache.flush", {
           attributes: {
             "cache.flush.index": flushes++,
@@ -120,39 +163,32 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     schema: schema(Manifest),
     freshFor,
     staleFor,
-    load: (context) => Effect_exports.runPromise(refresh(context), { signal: context.signal })
+    ...options.stale === void 0 ? {} : { stale: options.stale },
+    // A cache may call the loader as a Promise; its own signal cancels that load.
+    load: toPromise(refresh, (context) => context.signal)
   };
   let reading;
-  const current = () => cache === void 0 ? Effect_exports.fail(new CacheError({ reason: "unavailable" })) : invoke(
-    () => reading ??= cache.get(getOptions).finally(() => {
-      reading = void 0;
-    })
-  );
+  const current = () => Effect_exports.suspend(() => {
+    if (cache === void 0) return Effect_exports.fail(new CacheError({ reason: "unavailable" }));
+    const shared = reading;
+    if (shared !== void 0) return Deferred_exports.await(shared);
+    const deferred = Deferred_exports.makeUnsafe();
+    reading = deferred;
+    return fromPromise(
+      method(cache, "get"),
+      "cache"
+    )(getOptions).pipe(
+      Effect_exports.onExit(
+        (exit) => Effect_exports.sync(() => {
+          if (reading === deferred) reading = void 0;
+        }).pipe(Effect_exports.andThen(Deferred_exports.done(deferred, exit)))
+      )
+    );
+  });
   if (options.revalidate) {
     if (cache === void 0) yield* local;
-    else yield* invoke(() => cache.revalidate(getOptions));
+    else yield* fromPromise(method(cache, "revalidate"), "cache")(getOptions);
   }
-  const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
-    const batches = yield* Effect_exports.forEach(
-      Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
-      (offset) => invoke(
-        () => cache2.readMany(
-          Array.from(
-            { length: Math.min(4, count - offset) },
-            (_, index) => part(revision, kind, offset + index)
-          ),
-          schema(Schema_exports.Array(decoder))
-        )
-      ),
-      { concurrency: "unbounded" }
-    );
-    const values = [];
-    for (const page of batches.flat()) {
-      if (page === void 0) return yield* new CacheError({ reason: "unavailable" });
-      values.push(...page);
-    }
-    return values;
-  });
   const metadata = () => Effect_exports.gen(function* () {
     if (cache === void 0) return (yield* local).tools;
     const manifest = yield* current();
@@ -176,8 +212,9 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     }),
     resolve: (name) => cache === void 0 ? local.pipe(Effect_exports.map(({ tools }) => tools.find((tool) => tool.name === name))) : current().pipe(
       Effect_exports.flatMap(
-        (manifest) => invoke(
-          () => cache.read(part(manifest.revision, "tool", name), schema(options.schema))
+        (manifest) => fromPromise(method(cache, "read"), "cache")(
+          part(manifest.revision, "tool", name),
+          schema(options.schema)
         )
       )
     )
@@ -185,5 +222,6 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
 });
 
 export {
+  catalogScope,
   catalogCache
 };

package/js/{chunk-T7GKZBLP.js → chunk-JIU25DIL.js}

@@ -1,48 +1,20 @@
+import {
+  fromPromise
+} from "./chunk-T53665H5.js";
 import {
   HostedTool,
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-B3EOZTK3.js";
+} from "./chunk-TLWLJ7PD.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-VFZKSM3T.js → chunk-JPEUKEV4.js}

@@ -1,13 +1,13 @@
 import {
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/contracts/ui-auth.ts
-var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(
+var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/u)).pipe(
   Schema_exports.brand("AppSignInId")
 );
 var AppSignInCode = Schema_exports.RedactedFromValue(
-  Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/))
+  Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/u))
 );
 var AppReturnPath = Schema_exports.String.check(
   Schema_exports.isMaxLength(8192),