apps 0.0.1-beta.44 → 0.0.1-beta.47

package/js/{chunk-DZQYE626.js → chunk-7UUHJR2Q.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-MWKHKOTL.js";
 import {
   invocationFetch
-} from "./chunk-CZGWW4NQ.js";
+} from "./chunk-JM7LOD2W.js";
 import {
   Effect_exports,
   Schema_exports

package/js/{chunk-4ZTVLEN6.js → chunk-CDXQDN7W.js}

@@ -6,7 +6,7 @@ import {
   HttpApiGroup_exports,
   HttpApiSchema_exports,
   HttpApi_exports
-} from "./chunk-KSGYJV46.js";
+} from "./chunk-TUMGL2OC.js";
 import {
   Schema_exports
 } from "./chunk-IFJU5SYQ.js";

package/js/{chunk-V3RS2BK6.js → chunk-D45JTD6N.js}

@@ -1,12 +1,10 @@
 import {
   prepareElicitation
-} from "./chunk-DRJRCHHO.js";
+} from "./chunk-PO5NPRFT.js";
 import {
+  bodyUpstreamError,
   fromPromise
-} from "./chunk-OTGUPKKK.js";
-import {
-  bodyUpstreamError
-} from "./chunk-EMHFXFTJ.js";
+} from "./chunk-LTDHQJ2Z.js";
 import {
   ElicitationFailed,
   McpError,
@@ -18,12 +16,15 @@ import {
   defaultElicitationLimits,
   defaultMcpClientLimits,
   mcpSdkTimerCeilingMs
-} from "./chunk-ELO5PRCO.js";
+} from "./chunk-JY56GVSV.js";
 import {
   jsonSchemaDecoder,
   nestJsonSchema,
   preparedJsonSchemaDecoder
 } from "./chunk-KGCTYL2S.js";
+import {
+  owned
+} from "./chunk-JM7LOD2W.js";
 import {
   JsonObject
 } from "./chunk-H2CJWXA3.js";
@@ -187,11 +188,14 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
     const callbacks = /* @__PURE__ */ new Set();
     const lifetime = yield* Effect_exports.acquireRelease(
       Effect_exports.sync(() => new AbortController()),
-      (controller) => Effect_exports.promise(async () => {
-        controller.abort();
-        client.removeRequestHandler("elicitation/create");
-        await Promise.allSettled(callbacks);
-      })
+      (controller) => (
+        // oxlint-disable-next-line executor/authored-code-through-adapter -- the MCP SDK's elicitation callbacks
+        Effect_exports.promise(async () => {
+          controller.abort();
+          client.removeRequestHandler("elicitation/create");
+          await Promise.allSettled(callbacks);
+        })
+      )
     );
     client.setRequestHandler(ElicitRequestSchema, (request, extra) => {
       const signal = AbortSignal.any([lifetime.signal, extra.signal]);
@@ -203,7 +207,10 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
         const deliver = context.elicit;
         if (deliver === void 0) return yield* new ElicitationFailed({ reason: "unavailable" });
         const answer = yield* budget.waitForInput(
-          fromPromise(deliver)(form.request).pipe(
+          fromPromise(
+            deliver,
+            "elicitation"
+          )(form.request).pipe(
             Effect_exports.mapError(
               (error) => Option_exports.getOrElse(
                 Schema_exports.decodeUnknownOption(ElicitationFailed)(error),
@@ -253,7 +260,7 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
     );
   })
 ).pipe(
-  Effect_exports.withSpan("provider.mcp.request", {
+  owned("upstream", "provider.mcp.request", {
     kind: "client",
     attributes: {
       "rpc.system.name": "jsonrpc",
@@ -311,7 +318,7 @@ function mcpClient(withClient, timeoutMs, failure) {
           ),
           catch: (error) => failure("discover", error)
         }).pipe(
-          Effect_exports.withSpan("provider.mcp.request", {
+          owned("upstream", "provider.mcp.request", {
             kind: "client",
             attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
           })
@@ -352,25 +359,28 @@ function mcpClient(withClient, timeoutMs, failure) {
         server: Option_exports.getOrElse(server, () => ({}))
       };
     })
-  ).pipe(Effect_exports.withSpan("provider.mcp.discover"));
+  ).pipe(owned("upstream", "provider.mcp.discover"));
   const check = withClient(
     "discover",
-    (client) => Effect_exports.tryPromise({
-      try: (signal) => client.request({ method: "tools/list", params: {} }, ListToolsResultSchema, {
-        signal,
-        timeout: timeoutMs
-      }),
-      catch: (error) => failure("discover", error)
-    }).pipe(
-      Effect_exports.asVoid,
-      Effect_exports.withSpan("provider.mcp.request", {
-        kind: "client",
-        attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
-      })
+    (client) => (
+      // oxlint-disable-next-line executor/authored-code-through-adapter -- MCP SDK
+      Effect_exports.tryPromise({
+        try: (signal) => client.request({ method: "tools/list", params: {} }, ListToolsResultSchema, {
+          signal,
+          timeout: timeoutMs
+        }),
+        catch: (error) => failure("discover", error)
+      }).pipe(
+        Effect_exports.asVoid,
+        owned("upstream", "provider.mcp.request", {
+          kind: "client",
+          attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
+        })
+      )
     )
-  ).pipe(Effect_exports.withSpan("provider.mcp.check"));
+  ).pipe(owned("upstream", "provider.mcp.check"));
   const call = (name, input, context) => withClient("call", (client) => mcpCall(client, name, input, context, timeoutMs, failure)).pipe(
-    Effect_exports.withSpan("provider.mcp.call", { attributes: { "mcp.tool.name": name } })
+    owned("upstream", "provider.mcp.call", { attributes: { "mcp.tool.name": name } })
   );
   return { list, check, call };
 }

package/js/chunk-GDYPM7RS.js

@@ -0,0 +1,266 @@
+import {
+  declaredOperations,
+  nativeOperation,
+  nativeRouter
+} from "./chunk-X5U5KIWQ.js";
+import {
+  fromPromise,
+  method
+} from "./chunk-LTDHQJ2Z.js";
+import {
+  EmittedEvent,
+  EventName,
+  ScheduleTiming,
+  defaultEventLimits
+} from "./chunk-JY56GVSV.js";
+import {
+  decoderOf,
+  isSchema,
+  jsonSchemaDocument,
+  schemaArgument
+} from "./chunk-KGCTYL2S.js";
+import {
+  JsonValue
+} from "./chunk-H2CJWXA3.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/http.ts
+var ResponseStatusError = class extends Schema_exports.TaggedError()(
+  "ResponseStatusError",
+  { status: Schema_exports.Number }
+) {
+  get message() {
+    return `Request failed with status ${this.status}`;
+  }
+};
+var ResponseDecodeError = class extends Schema_exports.TaggedError()(
+  "ResponseDecodeError",
+  {}
+) {
+  get message() {
+    return "Response body did not match the expected schema";
+  }
+};
+
+// src/implementation/workflows.ts
+var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
+var workflow = (options, run) => ({
+  [NativeWorkflow]: {
+    input: decoderOf(schemaArgument(options.input, "The workflow input")),
+    ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, "The workflow output")) },
+    ...options.description === void 0 ? {} : { description: options.description },
+    // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
+    run: (context, input) => fromPromise(run, "workflow")(context, input)
+  }
+});
+var nativeWorkflow = (value) => {
+  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
+  return value[NativeWorkflow];
+};
+
+// src/implementation/events.ts
+var Native = /* @__PURE__ */ Symbol("apps.Event");
+var scalarTypes = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+var isScalarSchema = (document) => {
+  const type = document.type;
+  if (typeof type === "string") return scalarTypes.has(type);
+  const choices = Array.isArray(document.enum) ? document.enum : "const" in document ? [document.const] : void 0;
+  return choices !== void 0 && choices.length > 0 && choices.every((value) => ["string", "number", "boolean"].includes(typeof value));
+};
+var event = (options) => {
+  const filters = options.filters ?? {};
+  const fieldDecoders = Object.fromEntries(
+    Object.entries(filters).map(([key, field]) => [
+      key,
+      decoderOf(schemaArgument(field, `The event filter ${JSON.stringify(key)}`))
+    ])
+  );
+  for (const [key, decoder] of Object.entries(fieldDecoders)) {
+    const document = Effect_exports.runSync(jsonSchemaDocument(decoder));
+    if (!isScalarSchema(document))
+      throw new TypeError(
+        `The event filter ${JSON.stringify(key)} must be a string, number, boolean or literal`
+      );
+  }
+  return {
+    [Native]: {
+      description: options.description,
+      filters: fieldDecoders,
+      payload: decoderOf(schemaArgument(options.payload, "The event payload"))
+    },
+    description: options.description,
+    filters,
+    payload: options.payload
+  };
+};
+var nativeEvent = (declaration) => typeof declaration === "object" && declaration !== null && Native in declaration ? declaration[Native] : void 0;
+var declaredEvents = (events) => Effect_exports.forEach(
+  Object.entries(events),
+  ([name, declared]) => Effect_exports.gen(function* () {
+    const filters = yield* jsonSchemaDocument(Schema_exports.Struct(declared.filters));
+    const payload = yield* jsonSchemaDocument(declared.payload);
+    return [name, { description: declared.description, filters, payload }];
+  })
+).pipe(Effect_exports.map((entries) => Object.fromEntries(entries)));
+var makeEmitter = (input) => ({
+  emit: (name, data, ...rest) => {
+    const options = rest[0] ?? {};
+    const declared = Object.hasOwn(input.events, name) ? input.events[name] : void 0;
+    if (declared === void 0) throw new TypeError(`This app declares no event named "${name}"`);
+    if (input.emitted.length >= defaultEventLimits.maxEventsPerInvocation)
+      throw new RangeError(
+        `An invocation can emit at most ${defaultEventLimits.maxEventsPerInvocation} events`
+      );
+    const payload = Schema_exports.decodeUnknownSync(declared.payload)(data);
+    const filters = Schema_exports.decodeUnknownSync(Schema_exports.Struct(declared.filters))(
+      options.filters ?? {}
+    );
+    const account = options.account ?? input.sourceAccount ?? (input.accounts.length === 1 ? input.accounts[0] : void 0) ?? null;
+    if (account === null && input.accounts.length > 1)
+      throw new TypeError(
+        "This invocation has several accounts; name the one the event came from with { account }"
+      );
+    if (account !== null && !input.accounts.includes(account))
+      throw new TypeError("The event's account is not one of this invocation's accounts");
+    const occurredAt = options.occurredAt === void 0 ? Date.now() : options.occurredAt instanceof Date ? options.occurredAt.getTime() : options.occurredAt;
+    const occurrence = Schema_exports.decodeUnknownSync(EmittedEvent)({
+      name: Schema_exports.decodeUnknownSync(EventName)(name),
+      id: options.id ?? crypto.randomUUID(),
+      occurredAt,
+      data: payload,
+      filters,
+      account
+    });
+    if (new TextEncoder().encode(JSON.stringify(occurrence.data)).byteLength > defaultEventLimits.maxDataBytes)
+      throw new RangeError(
+        `An event's data can be at most ${defaultEventLimits.maxDataBytes} bytes of JSON; send a summary and a tool to read the rest`
+      );
+    input.emitted.push(occurrence);
+  }
+});
+
+// src/implementation/app.ts
+var InternalApp = /* @__PURE__ */ Symbol("apps.App");
+var isApp = (value) => typeof value === "object" && value !== null && InternalApp in value;
+var toEffectApp = (app) => app[InternalApp];
+function rejectCatalogs(definition) {
+  if ("queries" in definition || "mutations" in definition)
+    throw new Error("Put queries and mutations in a router under tools");
+}
+function adaptDefinition(definition) {
+  rejectCatalogs(definition);
+  const webhooks = definition.webhooks === void 0 ? {} : {
+    // SAFETY: `Required` only where the optional method was just checked to be present.
+    webhooks: Object.fromEntries(
+      Object.entries(definition.webhooks).map(([name, webhook]) => [
+        name,
+        {
+          ...webhook,
+          ...webhook.register === void 0 ? {} : {
+            register: fromPromise(
+              method(webhook, "register"),
+              "webhook"
+            )
+          },
+          handle: fromPromise(method(webhook, "handle"), "webhook"),
+          ...webhook.unregister === void 0 ? {} : {
+            unregister: fromPromise(
+              method(webhook, "unregister"),
+              "webhook"
+            )
+          },
+          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
+          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
+        }
+      ])
+    )
+  };
+  const workflows = definition.workflows === void 0 ? {} : {
+    workflows: Object.fromEntries(
+      Object.entries(definition.workflows).map(([name, value]) => {
+        const declared2 = nativeWorkflow(value);
+        if (declared2 === void 0) throw new Error("Invalid workflow declaration");
+        return [name, declared2];
+      })
+    )
+  };
+  const root = definition.tools === void 0 ? void 0 : nativeRouter(definition.tools);
+  if (definition.tools !== void 0 && root === void 0)
+    throw new Error("tools must be a router");
+  const data = root === void 0 ? {} : { tools: root };
+  const declared = root?.kind === "router" ? declaredOperations(root) : [];
+  const mutations = /* @__PURE__ */ new Set();
+  for (const { operation } of declared) {
+    if (operation.kind !== "mutation") continue;
+    if (mutations.has(operation))
+      throw new Error("A mutation can be mounted at only one path in tools");
+    mutations.add(operation);
+  }
+  const schedules = definition.schedules === void 0 ? {} : {
+    schedules: Object.fromEntries(
+      Object.entries(definition.schedules).map(([name, schedule]) => {
+        const target = nativeOperation(schedule.operation);
+        const match = declared.find(
+          ({ operation }) => operation === target && operation.kind === "mutation"
+        );
+        if (match === void 0)
+          throw new Error("A schedule must reference a mutation in this app's tools");
+        return [
+          name,
+          {
+            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
+            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
+            tool: match.name
+          }
+        ];
+      })
+    )
+  };
+  return {
+    ...definition,
+    ...webhooks,
+    ...workflows,
+    ...data,
+    ...schedules
+  };
+}
+var defineApp = (requirements, definition) => {
+  if (typeof definition !== "function") rejectCatalogs(definition);
+  const evaluate = typeof definition === "function" ? definition : async () => definition;
+  const factory = fromPromise(evaluate, "factory");
+  const events = requirements.events === void 0 ? void 0 : Object.fromEntries(
+    Object.entries(requirements.events).map(([name, declared]) => {
+      const native2 = nativeEvent(declared);
+      if (native2 === void 0)
+        throw new TypeError(
+          `The event ${JSON.stringify(name)} must be declared with event()`
+        );
+      return [name, native2];
+    })
+  );
+  const native = {
+    accounts: requirements.accounts,
+    ...events === void 0 ? {} : { events },
+    evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))
+  };
+  return {
+    [InternalApp]: native,
+    accounts: native.accounts,
+    evaluate: (context) => Effect_exports.runPromise(factory(context))
+  };
+};
+
+export {
+  ResponseStatusError,
+  ResponseDecodeError,
+  workflow,
+  event,
+  declaredEvents,
+  makeEmitter,
+  isApp,
+  toEffectApp,
+  defineApp
+};

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

@@ -1,6 +1,6 @@
 import {
   FetchHttpClient_exports
-} from "./chunk-MZH4J2PO.js";
+} from "./chunk-PD6I2SDG.js";
 import {
   recordedMessage
 } from "./chunk-5FHWNLCI.js";
@@ -23,7 +23,7 @@ import {
   tapError,
   transformResponse,
   uint8Array
-} from "./chunk-LNSVJS2Q.js";
+} from "./chunk-EOPQ727L.js";
 import {
   Array as Array2,
   Boolean2 as Boolean,
@@ -139,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(
@@ -170,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,
@@ -201,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
@@ -991,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;
       }
     }))
@@ -2344,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",
@@ -2491,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"),
@@ -2529,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([
@@ -2868,6 +3043,9 @@ var pendingSpan = (name, options) => Effect_exports.gen(function* () {
 
 export {
   CurrentTelemetryConfig,
+  owned,
+  measuredSpan,
+  makeOwnershipAccounting,
   OtlpExporter_exports,
   telemetryLayer,
   captureTelemetry,