apps 0.0.1-beta.44 → 0.0.1-beta.46

package/js/{chunk-646JVUH4.js → chunk-3B2JAOSE.js}

@@ -1,12 +1,15 @@
 import {
   declaredOperations,
-  fromPromise,
   nativeOperation,
   nativeRouter
-} from "./chunk-OTGUPKKK.js";
+} from "./chunk-LHCGND3R.js";
+import {
+  fromPromise,
+  method
+} from "./chunk-LTDHQJ2Z.js";
 import {
   ScheduleTiming
-} from "./chunk-ELO5PRCO.js";
+} from "./chunk-CVAJ4F6O.js";
 import {
   decoderOf,
   isSchema,
@@ -45,11 +48,8 @@ var workflow = (options, run) => ({
     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 },
-    run: (context, input) => Effect_exports.tryPromise({
-      // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
-      try: () => run(context, input),
-      catch: (error) => error
-    })
+    // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
+    run: (context, input) => fromPromise(run, "workflow")(context, input)
   }
 });
 var nativeWorkflow = (value) => {
@@ -68,14 +68,25 @@ function rejectCatalogs(definition) {
 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(webhook.register) },
-          handle: fromPromise(webhook.handle),
-          ...webhook.unregister === void 0 ? {} : { unregister: fromPromise(webhook.unregister) },
+          ...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) } : {}
         }
@@ -134,7 +145,7 @@ function adaptDefinition(definition) {
 var defineApp = (requirements, definition) => {
   if (typeof definition !== "function") rejectCatalogs(definition);
   const evaluate = typeof definition === "function" ? definition : async () => definition;
-  const factory = fromPromise(evaluate);
+  const factory = fromPromise(evaluate, "factory");
   const native = {
     accounts: requirements.accounts,
     evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))

package/js/{chunk-5SHUB37R.js → chunk-3UGDI2UI.js}

@@ -4,12 +4,12 @@ import {
 import {
   joinPath,
   mergeMeta
-} from "./chunk-OTGUPKKK.js";
+} from "./chunk-LHCGND3R.js";
 import {
   isShortenedUpstream,
   parseProviderError,
   providerError
-} from "./chunk-EMHFXFTJ.js";
+} from "./chunk-LTDHQJ2Z.js";
 import {
   ApiErrorResponse,
   HostDeclarationInvalid,
@@ -21,7 +21,7 @@ import {
   McpError,
   McpError2,
   SkillLoadFailed as SkillLoadFailed2
-} from "./chunk-ELO5PRCO.js";
+} from "./chunk-CVAJ4F6O.js";
 import {
   CacheError,
   FailureCode,

package/js/{chunk-7EBODVQJ.js → chunk-6QXPBJ5T.js}

@@ -3,16 +3,16 @@ import {
   answeredError,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-V3RS2BK6.js";
+} from "./chunk-XK5I2XOI.js";
 import {
   failOnNetworkRefusal
-} from "./chunk-DZQYE626.js";
+} from "./chunk-7UUHJR2Q.js";
 import {
   accountProviderError,
   bodyUpstreamError,
   httpProviderError,
   providerErrorDetail
-} from "./chunk-EMHFXFTJ.js";
+} from "./chunk-LTDHQJ2Z.js";
 import {
   McpCredentialsUnverified,
   McpError,
@@ -20,21 +20,22 @@ import {
   McpToolsOptions,
   defaultMcpClientLimits,
   mcpHealthReserveMs
-} from "./chunk-ELO5PRCO.js";
+} from "./chunk-CVAJ4F6O.js";
 import {
   NetworkRefused,
   ProviderError
 } from "./chunk-MWKHKOTL.js";
 import {
-  captureTelemetry
-} from "./chunk-CZGWW4NQ.js";
+  captureTelemetry,
+  owned
+} from "./chunk-JM7LOD2W.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-MZH4J2PO.js";
+} from "./chunk-PD6I2SDG.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-LNSVJS2Q.js";
+} from "./chunk-EOPQ727L.js";
 import {
   Clock_exports,
   Deferred_exports,
@@ -236,7 +237,7 @@ function withClient(connection, mode, use, changed) {
             Effect_exports.timeout(defaultMcpClientLimits.cleanupTimeoutMs),
             Effect_exports.ignore
           );
-        }).pipe(Effect_exports.withSpan("provider.mcp.close"))
+        }).pipe(owned("upstream", "provider.mcp.close"))
       );
       const wire = transport;
       yield* Effect_exports.tryPromise({
@@ -246,7 +247,7 @@ function withClient(connection, mode, use, changed) {
         Effect_exports.raceFirst(Deferred_exports.await(rejected)),
         Effect_exports.catch(explained("connect", answered)),
         Effect_exports.timeout(connection.timeoutMs),
-        Effect_exports.withSpan("provider.mcp.connect")
+        owned("upstream", "provider.mcp.connect")
       );
       return yield* use(client).pipe(
         Effect_exports.raceFirst(Deferred_exports.await(rejected)),
@@ -254,7 +255,7 @@ function withClient(connection, mode, use, changed) {
       );
     })
   ).pipe(
-    Effect_exports.withSpan("provider.mcp.session", {
+    owned("upstream", "provider.mcp.session", {
       attributes: {
         "mcp.transport": kind,
         "mcp.operation": mode,
@@ -327,9 +328,9 @@ var mcpHealthEffect = (check, options) => Effect_exports.gen(function* () {
       // Executor's network refused the attempt, so the server never answered it.
       onFailure: (error) => Schema_exports.is(NetworkRefused)(error) ? Effect_exports.fail(error) : refusesCredentials(error) ? Effect_exports.void : Effect_exports.fail(new McpCredentialsUnverified({ anonymous: error }))
     }),
-    Effect_exports.withSpan("provider.mcp.anonymous")
+    owned("upstream", "provider.mcp.anonymous")
   );
-}).pipe(Effect_exports.withSpan("provider.mcp.health"));
+}).pipe(owned("upstream", "provider.mcp.health"));
 var mcpToolsEffect = (input) => mcpClientEffect(input).pipe(Effect_exports.flatMap(adaptMcpTools));
 
 export {

package/js/{chunk-MGGMEGB2.js → chunk-7LGRK7TP.js}

@@ -1,11 +1,11 @@
 import {
   fixedRouter
-} from "./chunk-5SHUB37R.js";
+} from "./chunk-3UGDI2UI.js";
 import {
   nativeOperation,
   operationDeclaration,
   routerDeclaration
-} from "./chunk-OTGUPKKK.js";
+} from "./chunk-LHCGND3R.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {

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-ELO5PRCO.js → chunk-CVAJ4F6O.js}

@@ -3253,6 +3253,17 @@ var ToolResultObservation = Context_exports.Reference(
   { defaultValue: () => ({ failed: () => {
   } }) }
 );
+var InvocationTiming = Schema_exports.Struct({
+  elapsedMs: Schema_exports.Finite,
+  upstreamMs: Schema_exports.Finite,
+  elicitationMs: Schema_exports.Finite,
+  authoredMs: Schema_exports.Finite
+});
+var InvocationTimingSink = Context_exports.Reference(
+  "apps/InvocationTimingSink",
+  { defaultValue: () => () => {
+  } }
+);
 
 export {
   SecretsMethod,
@@ -3395,5 +3406,7 @@ export {
   HostCallError,
   HostAccountCheckError,
   HostDataError,
-  ToolResultObservation
+  ToolResultObservation,
+  InvocationTiming,
+  InvocationTimingSink
 };

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,

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-OTGUPKKK.js → chunk-LHCGND3R.js}

@@ -1,9 +1,12 @@
+import {
+  fromPromise
+} from "./chunk-LTDHQJ2Z.js";
 import {
   HostedTool,
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-ELO5PRCO.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,