apps 0.0.1-beta.43 → 0.0.1-beta.46

package/js/{chunk-VU6GQ2SH.js → chunk-JM7LOD2W.js}

@@ -1,9 +1,9 @@
 import {
   FetchHttpClient_exports
-} from "./chunk-MZH4J2PO.js";
+} from "./chunk-PD6I2SDG.js";
 import {
   recordedMessage
-} from "./chunk-EG72MSVK.js";
+} from "./chunk-5FHWNLCI.js";
 import {
   HttpBody_exports,
   HttpClient,
@@ -23,7 +23,7 @@ import {
   tapError,
   transformResponse,
   uint8Array
-} from "./chunk-LNSVJS2Q.js";
+} from "./chunk-EOPQ727L.js";
 import {
   Array as Array2,
   Boolean2 as Boolean,
@@ -44,6 +44,7 @@ import {
   Logger_exports,
   Metric_exports,
   Option_exports,
+  Predicate_exports,
   Record2 as Record,
   Redacted_exports,
   Schedule_exports,
@@ -138,6 +139,145 @@ import {
   __export
 } from "./chunk-CZ7CSFO4.js";
 
+// ../telemetry/src/ownership.ts
+var ownerAttribute = "executor.owner";
+var SpanOwner = Context_exports.Reference("@executor-js/telemetry/SpanOwner", {
+  defaultValue: () => void 0
+});
+var declaredOwner = (annotations) => Context_exports.get(annotations, SpanOwner);
+var ownedBy = (owner, options = {}) => ({
+  ...options,
+  annotations: Context_exports.add(options.annotations ?? Context_exports.empty(), SpanOwner, owner)
+});
+var owned = (owner, name, options) => (effect2) => effect2.pipe(Effect_exports.withSpan(name, ownedBy(owner, options)));
+var measuredSpan = (name, options, measure) => (effect2) => Effect_exports.useSpan(name, options, (span) => {
+  const inner = Effect_exports.withParentSpan(effect2, span);
+  if (span.status._tag === "Ended") return inner;
+  const { around, end } = measure(span.status.startTime);
+  return (around === void 0 ? inner : around(inner)).pipe(
+    Effect_exports.onExit(
+      (exit) => Effect_exports.flatMap(
+        Clock_exports.currentTimeNanos,
+        (now) => Effect_exports.sync(() => {
+          end(now, span);
+          span.end(now, exit);
+        })
+      )
+    )
+  );
+});
+var concurrent = ["executor", "person", "upstream", "app"];
+var makeOwnershipAccounting = (origin, owner) => {
+  const totals = { executor: 0, app: 0, upstream: 0, person: 0 };
+  const innermost = { executor: 0, app: 0, upstream: 0, person: 0 };
+  const boundaries2 = /* @__PURE__ */ new WeakMap();
+  let reached = origin;
+  let done = false;
+  const advance = (time) => {
+    if (time <= reached) return;
+    const current = concurrent.find((candidate) => innermost[candidate] > 0) ?? owner;
+    totals[current] += Number(time - reached) / 1e6;
+    reached = time;
+  };
+  const enclosing = (boundary) => {
+    let found = boundary.parent;
+    while (found !== void 0 && !found.open) found = found.parent;
+    boundary.parent = found;
+    return found;
+  };
+  const opened = (boundary) => {
+    const parent = enclosing(boundary);
+    if (parent !== void 0 && parent.children++ === 0) innermost[parent.owner] -= 1;
+    innermost[boundary.owner] += 1;
+  };
+  const closed = (boundary) => {
+    boundary.open = false;
+    if (boundary.children === 0) innermost[boundary.owner] -= 1;
+    const parent = enclosing(boundary);
+    if (parent === void 0) return;
+    parent.children += boundary.children - 1;
+    if (parent.children === 0) innermost[parent.owner] += 1;
+  };
+  const observed = (tracer) => ({
+    ...tracer,
+    span: (options) => {
+      const span = tracer.span(options);
+      if (done) return span;
+      const parent = Option_exports.getOrUndefined(options.parent);
+      const enclosingBoundary = parent === void 0 ? void 0 : boundaries2.get(parent);
+      const boundary = {
+        owner: declaredOwner(options.annotations) ?? enclosingBoundary?.owner ?? owner,
+        parent: enclosingBoundary,
+        open: true,
+        children: 0
+      };
+      advance(options.startTime);
+      opened(boundary);
+      const tracked = {
+        _tag: "Span",
+        get name() {
+          return span.name;
+        },
+        get spanId() {
+          return span.spanId;
+        },
+        get traceId() {
+          return span.traceId;
+        },
+        get parent() {
+          return span.parent;
+        },
+        get annotations() {
+          return span.annotations;
+        },
+        get status() {
+          return span.status;
+        },
+        get attributes() {
+          return span.attributes;
+        },
+        get links() {
+          return span.links;
+        },
+        get sampled() {
+          return span.sampled;
+        },
+        get kind() {
+          return span.kind;
+        },
+        end: (endTime, exit) => {
+          if (boundary.open && !done) {
+            advance(endTime);
+            closed(boundary);
+          }
+          span.end(endTime, exit);
+        },
+        attribute: (key, value) => span.attribute(key, value),
+        event: (name, startTime, attributes2) => span.event(name, startTime, attributes2),
+        addLinks: (links) => span.addLinks(links)
+      };
+      boundaries2.set(tracked, boundary);
+      return tracked;
+    }
+  });
+  return {
+    /** Run `effect` with the spans it opens observed, including spans it hands to later work. */
+    observe: (effect2) => Effect_exports.gen(function* () {
+      const tracer = yield* Tracer_exports.Tracer;
+      return yield* effect2.pipe(Effect_exports.provideService(Tracer_exports.Tracer, observed(tracer)));
+    }),
+    /**
+     * Close the window at `end` and return its milliseconds by owner, each instant counted once.
+     * Spans still open count up to `end`; spans that open or end afterwards are ignored.
+     */
+    read: (end) => {
+      if (!done) advance(end);
+      done = true;
+      return totals;
+    }
+  };
+};
+
 // ../telemetry/src/context.ts
 var captureTelemetry = Effect_exports.gen(function* () {
   let context2 = Context_exports.make(Tracer_exports.Tracer, yield* Tracer_exports.Tracer).pipe(
@@ -169,9 +309,10 @@ var invocationFetch = (signal) => Effect_exports.gen(function* () {
       const request = yield* Effect_exports.try(() => new Request(input, init));
       const client = yield* HttpClient_exports.HttpClient;
       const response = yield* client.execute(HttpClientRequest_exports.fromWeb(request)).pipe(
-        Effect_exports.withSpan("provider.http.request", {
-          attributes: { "http.request.method": request.method }
-        }),
+        Effect_exports.withSpan(
+          "provider.http.request",
+          ownedBy("upstream", { attributes: { "http.request.method": request.method } })
+        ),
         Effect_exports.provideService(FetchHttpClient_exports.RequestInit, {
           cache: request.cache,
           credentials: request.credentials,
@@ -200,9 +341,12 @@ var invocationFetch = (signal) => Effect_exports.gen(function* () {
         streamed,
         HttpBody_exports.stream(
           body.stream.pipe(
-            Stream_exports.withSpan("provider.http.response.read", {
-              attributes: { "http.response.status_code": response.status }
-            })
+            Stream_exports.withSpan(
+              "provider.http.response.read",
+              ownedBy("upstream", {
+                attributes: { "http.response.status_code": response.status }
+              })
+            )
           ),
           body.contentType,
           body.contentLength
@@ -882,18 +1026,29 @@ var retryTelemetryExport = (client) => client.pipe(
 );
 
 // ../telemetry/src/recorded-failure.ts
+var tagOf = (error) => Predicate_exports.hasProperty(error, "_tag") && Predicate_exports.isString(error._tag) ? error._tag : void 0;
+var recorded = (name, message) => {
+  const error = new Error(message);
+  error.name = name;
+  error.stack = message === "" ? name : `${name}: ${message}`;
+  return error;
+};
 var recordedError = (error) => {
-  const message = recordedMessage(error);
-  if (message === void 0 || !(error instanceof Error)) return error;
-  const recorded = new Error(message);
-  recorded.name = error.name;
-  recorded.stack = `${error.name}: ${message}`;
-  return recorded;
+  const tag = tagOf(error);
+  if (tag !== void 0) return recorded(tag, recordedMessage(error) ?? "");
+  if (!(error instanceof Error)) return recorded("UnrecognizedFailure", "");
+  if (error.cause === void 0) return error;
+  const copy = new Error(error.message, { cause: recordedError(error.cause) });
+  copy.name = error.name;
+  if (error.stack !== void 0) copy.stack = error.stack;
+  return copy;
 };
 var recordedCause = (cause) => Cause_exports.fromReasons(
-  Cause_exports.map(cause, recordedError).reasons.flatMap(
-    (reason) => Cause_exports.isDieReason(reason) && recordedMessage(reason.defect) !== void 0 ? Cause_exports.annotate(Cause_exports.die(recordedError(reason.defect)), Cause_exports.reasonAnnotations(reason)).reasons : [reason]
-  )
+  cause.reasons.flatMap((reason) => {
+    if (Cause_exports.isInterruptReason(reason)) return [reason];
+    const replaced = Cause_exports.isFailReason(reason) ? Cause_exports.fail(recordedError(reason.error)) : Cause_exports.die(recordedError(reason.defect));
+    return Cause_exports.annotate(replaced, Cause_exports.reasonAnnotations(reason)).reasons;
+  })
 );
 
 // ../telemetry/src/span-attributes.ts
@@ -979,6 +1134,8 @@ var spanAttributes = (clock, recordAll = false) => Layer_exports.effect(Tracer_e
         if (recordAll && Option_exports.isSome(options.parent) && options.parent.value._tag === "ExternalSpan")
           span.attribute("executor.trace.parent_sampled", options.parent.value.sampled);
         if (clock !== void 0) span.attribute("executor.clock.type", clock);
+        const owner = declaredOwner(options.annotations);
+        if (owner !== void 0) span.attribute(ownerAttribute, owner);
         return span;
       }
     }))
@@ -2332,10 +2489,15 @@ var appSpanNames = /* @__PURE__ */ new Set([
   "app.catalog.read",
   "app.skills.load",
   "app.skills.routers",
+  "app.tool.resolve",
   "app.tool.approval",
   "app.tool.elicitation",
+  "app.elicitation.wait",
+  "app.workflow.control",
   "app.operation.execute",
   "app.sql.migrate",
+  "app.code",
+  "app.cache.call",
   "app.cache.get",
   "app.cache.load",
   "app.cache.command",
@@ -2479,6 +2641,10 @@ var status = (value) => {
   const found = integer(value);
   return found !== void 0 && found >= 100 && found <= 599 ? { intValue: found } : void 0;
 };
+var duration = (value) => {
+  const found = typeof value["doubleValue"] === "number" ? value["doubleValue"] : integer(value);
+  return found !== void 0 && Number.isFinite(found) && found >= 0 ? { doubleValue: found } : void 0;
+};
 var spanAttributes2 = {
   "executor.operation": oneOf(...operations, "mutation", "discover"),
   "executor.outcome": oneOf("failed"),
@@ -2517,7 +2683,28 @@ var spanAttributes2 = {
   "url.scheme": oneOf("http", "https"),
   "span.label": oneOf("\u26A0\uFE0E Interrupted"),
   "status.interrupted": flag,
-  "executor.milestone.reached": flag
+  "executor.milestone.reached": flag,
+  "executor.owner": oneOf("executor", "app", "upstream", "person"),
+  "executor.app.code": oneOf(
+    "factory",
+    "router",
+    "approval",
+    "handler",
+    "loader",
+    "cache",
+    "webhook",
+    "check",
+    "skills",
+    "elicitation",
+    "workflow",
+    "step"
+  ),
+  "executor.workflow.operation": oneOf("start", "get", "list", "terminate"),
+  "cache.method": oneOf("get", "revalidate", "read", "readMany", "write", "invalidate"),
+  "executor.upstream.wait_ms": duration,
+  "executor.elicitation.wait_ms": duration,
+  "executor.authored_ms": duration,
+  "executor.overhead_ms": duration
 };
 var appSpanAttributeKeys = new Set(Object.keys(spanAttributes2));
 var logMessages = /* @__PURE__ */ new Set([
@@ -2543,15 +2730,15 @@ var exception = (event) => {
     (attribute) => isObject(attribute) && attribute["key"] === "exception.type"
   );
   const type = isObject(named) && isObject(named["value"]) ? text(named["value"]) : void 0;
-  const recorded = type !== void 0 && errorKinds.has(type) ? type : unrecognized;
+  const recorded2 = type !== void 0 && errorKinds.has(type) ? type : unrecognized;
   const time = nanos(event["timeUnixNano"]);
   return {
     name: "exception",
     ...time === void 0 ? {} : { timeUnixNano: time },
     attributes: [
-      { key: "exception.type", value: { stringValue: recorded } },
+      { key: "exception.type", value: { stringValue: recorded2 } },
       { key: "exception.message", value: { stringValue: appText } },
-      { key: "exception.stacktrace", value: { stringValue: `${recorded}: ${appText}` } }
+      { key: "exception.stacktrace", value: { stringValue: `${recorded2}: ${appText}` } }
     ]
   };
 };
@@ -2856,6 +3043,9 @@ var pendingSpan = (name, options) => Effect_exports.gen(function* () {
 
 export {
   CurrentTelemetryConfig,
+  owned,
+  measuredSpan,
+  makeOwnershipAccounting,
   OtlpExporter_exports,
   telemetryLayer,
   captureTelemetry,

package/js/{chunk-EJUK2NK5.js → chunk-KLYSEHUD.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-JPEUKEV4.js";
 import {
   HttpServerResponse_exports
-} from "./chunk-LNSVJS2Q.js";
+} from "./chunk-EOPQ727L.js";
 
 // src/implementation/ui-auth.ts
 var appPrivateHeaders = {

package/js/{chunk-ILYK7BQG.js → chunk-LHCGND3R.js}

@@ -1,9 +1,12 @@
+import {
+  fromPromise
+} from "./chunk-LTDHQJ2Z.js";
 import {
   HostedTool,
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-OBXHQNWC.js";
+} from "./chunk-CVAJ4F6O.js";
 import {
   decoderOf,
   schemaArgument
@@ -13,38 +16,6 @@ import {
   Schema_exports
 } from "./chunk-IFJU5SYQ.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
-  });
-};
-
 // src/implementation/operations.ts
 var NativeOperation = /* @__PURE__ */ Symbol("apps.Operation");
 var NativeRouterKey = /* @__PURE__ */ Symbol("apps.Router");
@@ -65,7 +36,7 @@ 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")()
     }
   };
 };
@@ -73,7 +44,7 @@ var approvedOperation = (operation, approval) => {
   const copy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(operation));
   return Object.defineProperty(copy, "approval", {
     enumerable: true,
-    value: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
+    value: (context) => fromPromise(async () => approval(context), "approval")()
   });
 };
 var withApproval = (operation, approval) => ({
@@ -86,12 +57,9 @@ var make = (kind, options, run) => operationDeclaration({
   kind,
   // The host always validates JSON serialization, even without a stronger output declaration.
   ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, `The ${kind} 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
-  })
+  // 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);
@@ -139,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);
@@ -235,8 +203,6 @@ var withApprovals = (source, policy) => {
 };
 
 export {
-  fromPromise,
-  toPromise,
   operationDeclaration,
   nativeOperation,
   withApproval,

package/js/{chunk-EMHFXFTJ.js → chunk-LTDHQJ2Z.js}

@@ -2,14 +2,63 @@ import {
   ProviderError,
   maxUpstreamMessageLength
 } from "./chunk-MWKHKOTL.js";
+import {
+  owned
+} from "./chunk-JM7LOD2W.js";
 import {
   AccountId
 } from "./chunk-H2CJWXA3.js";
 import {
+  Effect_exports,
   Option_exports,
   Schema_exports
 } from "./chunk-IFJU5SYQ.js";
 
+// src/implementation/authoring.ts
+var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
+var appCode = (code) => owned("app", "app.code", { attributes: { "executor.app.code": code } });
+var fromPromise = (callback, code) => (...args) => {
+  if (NativeCallback in callback) {
+    const native = callback[NativeCallback];
+    return native(...args);
+  }
+  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error }).pipe(
+    appCode(code)
+  );
+};
+var method = (target, key) => {
+  const value = target[key];
+  const call = (...args) => Reflect.apply(value, target, args);
+  if (NativeCallback in value) Object.assign(call, { [NativeCallback]: value[NativeCallback] });
+  return call;
+};
+var toPromise = (operation, signalOf, services) => {
+  const native = (...args) => Effect_exports.suspend(() => {
+    const signal = typeof signalOf === "function" ? signalOf(...args) : signalOf;
+    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) => services === void 0 ? Effect_exports.runPromise(native(...args)) : Effect_exports.runPromiseWith(services)(native(...args)),
+    {
+      [NativeCallback]: native
+    }
+  );
+};
+
 // src/implementation/upstream-error.ts
 var ErrorToken = Schema_exports.String.check(Schema_exports.isPattern(/^[A-Za-z0-9._-]{1,128}$/u));
 var JsonRpcError = Schema_exports.Struct({
@@ -107,6 +156,10 @@ function graphqlProviderError(errors, status) {
 }
 
 export {
+  appCode,
+  fromPromise,
+  method,
+  toPromise,
   isShortenedUpstream,
   bodyUpstreamError,
   providerError,