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

package/js/chunk-YNJ5CZMJ.js

@@ -0,0 +1,93 @@
+import {
+  JsonValue
+} from "./chunk-DDHBUKXX.js";
+import {
+  HttpApiEndpoint_exports,
+  HttpApiGroup_exports,
+  HttpApiSchema_exports,
+  HttpApi_exports
+} from "./chunk-TUMGL2OC.js";
+import {
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/ui.ts
+var UiContext = Schema_exports.Struct({
+  deployment: Schema_exports.NonEmptyString,
+  accounts: Schema_exports.optional(
+    Schema_exports.Record(Schema_exports.NonEmptyString, Schema_exports.Array(Schema_exports.NonEmptyString))
+  )
+});
+var UiOperation = Schema_exports.Struct({
+  ...UiContext.fields,
+  name: Schema_exports.NonEmptyString,
+  input: JsonValue
+});
+var UiUnauthorized = class extends Schema_exports.TaggedError()(
+  "UiUnauthorized",
+  {},
+  { httpApiStatus: 401 }
+) {
+};
+var UiForbidden = class extends Schema_exports.TaggedError()(
+  "UiForbidden",
+  {},
+  { httpApiStatus: 403 }
+) {
+};
+var UiDeploymentChanged = class extends Schema_exports.TaggedError()(
+  "UiDeploymentChanged",
+  {},
+  { httpApiStatus: 409 }
+) {
+};
+var UiFailed = class extends Schema_exports.TaggedError()(
+  "UiFailed",
+  {
+    reason: Schema_exports.Literals(["unavailable", "operation_failed", "account_required"])
+  },
+  { httpApiStatus: 422 }
+) {
+};
+var UiSnapshot = Schema_exports.Union([
+  Schema_exports.Struct({
+    type: Schema_exports.Literal("snapshot"),
+    value: JsonValue,
+    trace: Schema_exports.optional(Schema_exports.Unknown)
+  }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("failure"), error: UiFailed }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("heartbeat") })
+]);
+var errors = [UiUnauthorized, UiForbidden, UiDeploymentChanged, UiFailed];
+var AppUiApi = HttpApi_exports.make("app-ui").add(
+  HttpApiGroup_exports.make("ui").add(
+    HttpApiEndpoint_exports.post("query", "/_executor/api/query", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("mutate", "/_executor/api/mutate", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("subscribe", "/_executor/api/subscribe", {
+      payload: UiOperation,
+      success: HttpApiSchema_exports.StreamSse({ data: UiSnapshot, error: Schema_exports.Union(errors) }),
+      error: errors
+    })
+  )
+);
+
+export {
+  UiContext,
+  UiOperation,
+  UiUnauthorized,
+  UiForbidden,
+  UiDeploymentChanged,
+  UiFailed,
+  UiSnapshot,
+  AppUiApi
+};

package/js/chunk-YRGL4QEF.js

@@ -0,0 +1,49 @@
+import {
+  FetchOptionUnsupported,
+  NetworkRefusedHeader,
+  RestrictedFetchOption,
+  networkRefusalHeader,
+  networkRefusalStatus,
+  supportedFetchOptions
+} from "./chunk-6XQLA5NC.js";
+import {
+  invocationFetch
+} from "./chunk-QWQM3CLH.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/implementation/network.ts
+var refusalHeader = (status, header) => status === networkRefusalStatus && header !== null && header !== void 0 ? header : void 0;
+var failOnNetworkRefusal = (response) => {
+  const header = refusalHeader(response.status, response.headers[networkRefusalHeader]);
+  return header === void 0 ? Effect_exports.void : Schema_exports.decodeUnknownEffect(NetworkRefusedHeader)(header).pipe(
+    Effect_exports.orDie,
+    Effect_exports.flatMap(Effect_exports.fail)
+  );
+};
+var unsupportedOption = (init) => {
+  for (const option of RestrictedFetchOption.literals) {
+    const value = init?.[option];
+    const supported = supportedFetchOptions[option];
+    if (value !== void 0 && !supported.includes(value))
+      return new FetchOptionUnsupported({ option, value: String(value), supported });
+  }
+  return void 0;
+};
+var appFetch = (fetch) => async (input, init) => {
+  const unsupported = unsupportedOption(init);
+  if (unsupported !== void 0) throw unsupported;
+  const response = await fetch(input, init);
+  const header = refusalHeader(response.status, response.headers.get(networkRefusalHeader));
+  if (header === void 0) return response;
+  await response.body?.cancel();
+  throw Schema_exports.decodeUnknownSync(NetworkRefusedHeader)(header);
+};
+var appInvocationFetch = (signal) => invocationFetch(signal).pipe(Effect_exports.map(appFetch));
+
+export {
+  failOnNetworkRefusal,
+  appInvocationFetch
+};

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

@@ -1,48 +1,20 @@
+import {
+  fromPromise
+} from "./chunk-I5C7FD5Z.js";
 import {
   HostedTool,
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-WLE7WX2U.js";
+} from "./chunk-6XQLA5NC.js";
 import {
-  decoderOf
-} from "./chunk-5T57N25Q.js";
+  decoderOf,
+  schemaArgument
+} from "./chunk-GQ33QSNB.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,31 +36,38 @@ 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 withApproval = (operation, approval) => ({
-  ...operation,
-  [NativeOperation]: {
-    ...operation[NativeOperation],
-    approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
+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) => (
+  // SAFETY: `Approved` is a type-only mark; the native operation now carries the approval.
+  {
+    ...operation,
+    [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);
+function mutation(options, run) {
+  return make("mutation", options, run);
+}
 
 // src/implementation/router.ts
 var routerDeclaration = (node) => ({
@@ -133,14 +112,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 +168,87 @@ 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, ""));
+};
+var renameTools = (source, rename) => {
+  const native = nativeRouter(source);
+  if (native?.kind !== "dynamic") throw new Error("renameTools expects a protocol router");
+  const exposed = (tools) => {
+    const seen = /* @__PURE__ */ new Set();
+    return tools.flatMap((tool) => {
+      const name = rename(tool.name);
+      if (name === void 0 || seen.has(name)) return [];
+      seen.add(name);
+      return [{ ...tool, name, source: tool.name }];
+    });
+  };
+  const listed = native.summaries ?? native.list;
+  const original = (name) => listed().pipe(Effect_exports.map((tools) => exposed(tools).find((tool) => tool.name === name)?.source));
+  const strip = ({
+    source: _source,
+    ...tool
+  }) => tool;
+  return routerDeclaration({
+    ...native,
+    list: () => native.list().pipe(Effect_exports.map((tools) => exposed(tools).map(strip))),
+    ...native.summaries === void 0 ? {} : {
+      summaries: () => listed().pipe(Effect_exports.map((tools) => exposed(tools).map(strip)))
+    },
+    describe: (name) => original(name).pipe(
+      Effect_exports.flatMap(
+        (found) => found === void 0 ? Effect_exports.succeed(void 0) : native.describe?.(found) ?? native.list().pipe(Effect_exports.map((tools) => tools.find((tool) => tool.name === found)))
+      ),
+      Effect_exports.map((tool) => tool === void 0 ? void 0 : { ...tool, name })
+    ),
+    resolve: (name) => original(name).pipe(
+      Effect_exports.flatMap(
+        (found) => found === void 0 ? Effect_exports.succeed(void 0) : native.resolve(found)
+      )
+    )
+  });
+};
 
 export {
-  fromPromise,
-  toPromise,
   operationDeclaration,
   nativeOperation,
   withApproval,
+  toolAnnotations,
   query,
   mutation,
   routerDeclaration,
@@ -205,5 +258,7 @@ export {
   dynamicRouter,
   joinPath,
   locate,
-  declaredOperations
+  declaredOperations,
+  withApprovals,
+  renameTools
 };