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

package/types/apps/src/host.d.ts

@@ -6,6 +6,11 @@ export { isolatedCacheSession } from "./implementation/cache-session.js";
 export declare const hostContext: (accounts: ResolvedAccountsInput, approval?: unknown) => HostContext;
 /** Portable Promise handler. Invoke only after the host has authorized and resolved accounts. */
 export declare const createAppHandler: (app: unknown) => ((request: Request, context: HostContext) => Promise<Response>);
+/**
+ * The clock this framework's spans read, in nanoseconds. The runtime's bridge times the isolate's
+ * whole dispatch with it, so that time and the invocation's own timing share one clock.
+ */
+export declare const isolatedClock: () => bigint;
 /** Isolates return bounded, telemetry beside the protocol result; no exporter secret enters app code. */
 export declare const createIsolatedAppHandler: (app: unknown) => (request: Request, context: HostContext) => Promise<Response>;
 /**

package/types/apps/src/implementation/authoring.d.ts

@@ -1,12 +1,32 @@
 /** Small, explicit adapters between authored callbacks and native Effect operations. */
-import { Effect } from "effect";
+import { Effect, type Context } from "effect";
 /** Project one Effect operation into its author-facing Promise signature. */
 export type PromiseMethod<Method> = Method extends (...args: infer Args) => Effect.Effect<infer A, infer _E> ? (...args: Args) => Promise<A> : Method;
 /** Project only an object's methods; data and schema types are not recursively rewritten. */
 export type PromiseMethods<T> = {
     readonly [Key in keyof T]: PromiseMethod<T[Key]>;
 };
-/** Reuse a framework callback's cancellation-bound Effect, or adapt an ordinary async callback. */
-export declare const fromPromise: <Args extends readonly unknown[], A>(callback: (...args: Args) => Promise<A>) => ((...args: Args) => Effect.Effect<A, unknown>);
-/** Bind cancellation once so Promise callers and native framework callers run the same operation. */
-export declare const toPromise: <Args extends readonly unknown[], A, E>(operation: (...args: Args) => Effect.Effect<A, E>, signal?: AbortSignal) => ((...args: Args) => Promise<A>);
+/** Which of the app's callbacks runs, recorded on the `app.code` span around it. */
+export type AppCode = "factory" | "router" | "approval" | "handler" | "loader" | "cache" | "webhook" | "check" | "skills" | "elicitation" | "workflow" | "step";
+/**
+ * Run `effect` as the app's own code. Its time is the app's, except for work it starts for
+ * Executor, an upstream or a person, which opens its own boundary inside.
+ */
+export declare const appCode: (code: AppCode) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, import("effect/Tracer").ParentSpan>>;
+/**
+ * Reuse a framework callback's cancellation-bound Effect, or run an ordinary async callback as the
+ * app's code. Every callback an app supplies enters the framework here, so its time is the app's.
+ */
+export declare const fromPromise: <Args extends readonly unknown[], A>(callback: (...args: Args) => Promise<A>, code: AppCode) => ((...args: Args) => Effect.Effect<A, unknown>);
+/**
+ * `target[key]`, called on `target`. A method read off its object as a bare value loses its
+ * receiver, so an app's method, such as one of its cache's, enters `fromPromise` through this.
+ */
+export declare const method: <K extends PropertyKey, T extends { readonly [P in K]: (...args: never) => unknown; }>(target: T, key: K) => T[K];
+/**
+ * Bind cancellation once so Promise callers and native framework callers run the same operation.
+ * `signalOf` is the signal, or reads it from each call's arguments, such as a loader's `context.signal`.
+ */
+export declare const toPromise: <Args extends readonly unknown[], A, E>(operation: (...args: Args) => Effect.Effect<A, E>, signalOf?: AbortSignal | ((...args: Args) => AbortSignal), 
+/** Services a Promise call runs with, such as its invocation's telemetry. */
+services?: Context.Context<never>) => ((...args: Args) => Promise<A>);

package/types/apps/src/implementation/cache.d.ts

@@ -1,8 +1,12 @@
+/** Bind the portable Effect cache to an app invocation's author API. */
+import { type Context } from "effect";
 import type { AppCache, HostCache } from "../contracts/cache.js";
 import type { ResolvedAccounts } from "../contracts/host.js";
 /** Missing host support is explicit on use; ordinary apps do not need cache support. */
 export declare const unavailableCache: HostCache;
 /** Account scopes are derived from trusted current bindings. Loaders get a fresh owned HTTP signal. */
 export declare const authorCache: (host: HostCache, accounts: ResolvedAccounts, signal: AbortSignal, 
+/** The invocation's telemetry, which Promise calls from authored code run in. */
+telemetry: Context.Context<never>, 
 /** The invocation's trusted deadline. Waiting on another caller's load never runs past it. */
 deadline?: number) => AppCache;

package/types/apps/src/implementation/elicitation.d.ts

@@ -1,5 +1,5 @@
 /** Validate both sides of a tool's form and bind delivery to its invocation lifetime. */
-import { Effect, Schema } from "effect";
+import { Effect, Schema, type Context } from "effect";
 import { ElicitationFailed, type ElicitationHandler, type Elicit } from "../contracts/elicitation.js";
 /** Parse a form and retain its response parser, so invalid answers can be rejected before consuming a host continuation. */
 export declare const prepareElicitation: (input: unknown) => Effect.Effect<{
@@ -99,5 +99,8 @@ export declare const prepareElicitation: (input: unknown) => Effect.Effect<{
         } | undefined;
     }, ElicitationFailed, never>;
 }, ElicitationFailed, never>;
-/** Bind a validated interaction to the live invocation; transport adapters share its form parser. */
-export declare const makeElicit: (handler: ElicitationHandler | undefined, signal: AbortSignal) => Elicit;
+/**
+ * Bind a validated interaction to the live invocation; transport adapters share its form parser.
+ * Authored code's Promise calls run in the invocation's telemetry, like framework callers.
+ */
+export declare const makeElicit: (handler: ElicitationHandler | undefined, signal: AbortSignal, telemetry: Context.Context<never>) => Elicit;

package/types/apps/src/implementation/events.d.ts

@@ -0,0 +1,59 @@
+/** Event declarations and the per-invocation emitter. Emitted events leave in the reply. */
+import { Effect, Schema as EffectSchema } from "effect";
+import { EmittedEvent, type AppEvent, type EmitOptions } from "../contracts/events.js";
+import { type Fields, type Infer, type ObjectValue, type Schema } from "./schema.js";
+declare const Native: unique symbol;
+/** An event an app emits. Declare it in `defineApp`'s requirements under `events`. */
+export interface EventDeclaration<F extends Fields, P extends Schema<unknown, boolean>> {
+    readonly [Native]: AppEvent;
+    readonly description: string;
+    readonly filters: F;
+    readonly payload: P;
+}
+/** Any declared event, for requirement constraints. */
+export type AnyEventDeclaration = EventDeclaration<Fields, Schema<unknown, boolean>>;
+/**
+ * Declare an event. `filters` are scalar fields subscribers can narrow on, such as a repository;
+ * every emitted occurrence supplies their values. `payload` describes each occurrence's data.
+ */
+export declare const event: <const F extends Fields = {}, P extends Schema<unknown, boolean> = Schema<unknown>>(options: {
+    readonly description: string;
+    readonly filters?: F;
+    readonly payload: P;
+}) => EventDeclaration<F, P>;
+/** The native declaration retained by an author event. */
+export declare const nativeEvent: (declaration: unknown) => AppEvent | undefined;
+/** JSON Schema for each declared event, as the host reads it from requirements. */
+export declare const declaredEvents: (events: Readonly<Record<string, AppEvent>>) => Effect.Effect<{
+    readonly [x: string]: {
+        readonly description: string;
+        readonly filters: {
+            readonly [x: string]: EffectSchema.Json;
+        };
+        readonly payload: {
+            readonly [x: string]: EffectSchema.Json;
+        };
+    };
+}, EffectSchema.SchemaError, never>;
+/** Emit options typed by the event's filters: required exactly when it declares some. */
+type OptionsFor<F extends Fields> = keyof F extends never ? [options?: Omit<EmitOptions<never>, "filters">] : [options: EmitOptions<ObjectValue<F>> & {
+    readonly filters: ObjectValue<F>;
+}];
+/** `ctx.events` in mutations and webhook handlers. */
+export interface EventEmitter<Events extends Readonly<Record<string, AnyEventDeclaration>>> {
+    /**
+     * Record an occurrence. It is delivered only if this invocation succeeds. Invalid data, filters
+     * or options throw here, before anything is recorded.
+     */
+    readonly emit: <Name extends keyof Events & string>(name: Name, data: Infer<Events[Name]["payload"]>, ...options: OptionsFor<Events[Name]["filters"]>) => void;
+}
+/** One invocation's buffer. The handler reads `emitted` only after the invocation succeeds. */
+export declare const makeEmitter: (input: {
+    readonly events: Readonly<Record<string, AppEvent>>;
+    /** Every account ID bound to this invocation. */
+    readonly accounts: readonly string[];
+    /** The webhook's source account, which an emit names by default. */
+    readonly sourceAccount?: string;
+    readonly emitted: EmittedEvent[];
+}) => EventEmitter<Readonly<Record<string, AnyEventDeclaration>>>;
+export {};

package/types/apps/src/implementation/invocation-timing.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Divide a tool invocation's time, on its own isolate's clock, by who the work belonged to:
+ * Executor, the app's authored code, upstream providers, or a person answering an elicitation.
+ * Each boundary declares its owner where the work starts (see `owned`); the invocation's own span is
+ * Executor's. The host adds the other isolates' parts.
+ */
+import { Effect } from "effect";
+/** The span `makeElicit` opens while a person answers. */
+export declare const elicitationWaitSpan = "app.elicitation.wait";
+/** The span around each workflow control an app calls, which Executor answers. */
+export declare const workflowControlSpan = "app.workflow.control";
+/**
+ * Run a tool operation in its `app.<operation>` span and time it from the span's own start to its
+ * own end. The span records each part, and the isolated handler returns them to the host.
+ */
+export declare const timedInvocation: (operation: "call" | "query" | "mutate") => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, import("effect/Tracer").ParentSpan>>;

package/types/apps/src/implementation/operations.d.ts

@@ -1,5 +1,5 @@
 /** Pure operation declarations. Only the author callback crosses the Promise boundary. */
-import { Effect, Schema as EffectSchema } from "effect";
+import { Schema as EffectSchema } from "effect";
 import type { AppOperation } from "../contracts/operations.js";
 import type { AppContext, QueryContext, MutationContext } from "../contracts/context.js";
 import type { Approval } from "../approval.js";
@@ -64,7 +64,7 @@ export interface OperationOptions<Input, Output> {
 }
 /** Adapt metadata and approval without running user code. */
 export declare const operationOptions: <Input, Output>(options: OperationOptions<Input, Output>) => {
-    approval?: (context: Parameters<Approval<Input>>[0]) => Effect.Effect<"approved" | "denied" | "user-approval", unknown, never>;
+    approval?: (context: Parameters<Approval<Input>>[0]) => import("effect/Effect").Effect<"approved" | "denied" | "user-approval", unknown, never>;
     input: EffectSchema.Decoder<Input, never>;
     _meta?: {
         readonly [x: string]: EffectSchema.Json;

package/types/apps/src/implementation/router-catalog.d.ts

@@ -29,6 +29,7 @@ export declare const routerSkillName: (path: string) => string;
 export declare const operationSummary: (name: string, router: string, operation: AppOperation, schedules?: readonly OperationSchedule[]) => Effect.Effect<{
     readonly description: string;
     readonly name: string;
+    readonly router?: string;
     readonly title?: string;
     readonly annotations?: {
         readonly title?: string;
@@ -52,7 +53,6 @@ export declare const operationSummary: (name: string, router: string, operation:
         readonly input: Schema.Json;
     }[];
     readonly readOnly?: boolean;
-    readonly router?: string;
     readonly tags?: readonly string[];
 }, HostDeclarationInvalid, never>;
 /** A declared operation's full description, including rendered schemas. */
@@ -65,6 +65,7 @@ export declare const operationDescription: (name: string, router: string, operat
     readonly _meta?: {
         readonly [x: string]: Schema.Json;
     };
+    readonly router?: string;
     readonly title?: string;
     readonly annotations?: {
         readonly title?: string;
@@ -91,7 +92,6 @@ export declare const operationDescription: (name: string, router: string, operat
         readonly input: Schema.Json;
     }[];
     readonly readOnly?: boolean;
-    readonly router?: string;
     readonly tags?: readonly string[];
 }, HostDeclarationInvalid, never>;
 /**
@@ -128,6 +128,7 @@ export declare const readCatalog: (root: AppRouter | DynamicRouter | undefined,
         readonly _meta?: {
             readonly [x: string]: Schema.Json;
         };
+        readonly router?: string;
         readonly title?: string;
         readonly annotations?: {
             readonly title?: string;
@@ -154,11 +155,11 @@ export declare const readCatalog: (root: AppRouter | DynamicRouter | undefined,
             readonly input: Schema.Json;
         }[];
         readonly readOnly?: boolean;
-        readonly router?: string;
         readonly tags?: readonly string[];
     } | {
         readonly description: string;
         readonly name: string;
+        readonly router?: string;
         readonly title?: string;
         readonly annotations?: {
             readonly title?: string;
@@ -182,7 +183,6 @@ export declare const readCatalog: (root: AppRouter | DynamicRouter | undefined,
             readonly input: Schema.Json;
         }[];
         readonly readOnly?: boolean;
-        readonly router?: string;
         readonly tags?: readonly string[];
     })[];
     routers: {

package/types/apps/src/implementation/sql.d.ts

@@ -22,6 +22,11 @@ export interface StepReplay {
 export declare const authorSql: (storage: AppSqlStorage, options: {
     readonly signal: AbortSignal;
     readonly step?: StepReplay;
+    /**
+     * The invocation's emitted events. A transaction that rolls back also discards the events its
+     * callback emitted, so subscribers never hear of writes that did not commit.
+     */
+    readonly emitted?: unknown[];
 }) => {
     reader: SqlReader;
     writer: Sql;

package/types/apps/src/implementation/workflows.d.ts

@@ -1,5 +1,5 @@
 /** Ordinary async workflow declarations, adapted once into native Effect handlers. */
-import { type Schema as EffectSchema } from "effect";
+import type { Schema as EffectSchema } from "effect";
 import type { AppWorkflow, WorkflowContext } from "../contracts/workflows.js";
 import { type Schema } from "./schema.js";
 declare const NativeWorkflow: unique symbol;

package/types/apps/src/index.d.ts

@@ -59,6 +59,8 @@ export declare function oauth2<Response extends Schema<unknown, boolean>>(option
 export type { AccountSlots } from "./contracts/app.js";
 export type { AppRequirements, AppContext, QueryContext, MutationContext, WebhookContext, } from "./contracts/context.js";
 export { type App, type AppDefinition, defineApp } from "./implementation/app.js";
+export { event, type EventDeclaration, type EventEmitter } from "./implementation/events.js";
+export type { EmitOptions } from "./contracts/events.js";
 export type { Approval, ApprovalContext, ApprovalDecision } from "./approval.js";
 type AuthorWebhook<Member, Config, State> = Member extends object ? Omit<PromiseMethods<Member>, "config" | "state"> & {
     readonly config: Config;

package/types/telemetry/src/index.d.ts

@@ -5,5 +5,6 @@ export { captureTelemetry, traceHeaders, withRemoteSpan, invocationFetch, type I
 export { collectTelemetry, forwardTelemetry, makeTelemetryForwarder, TelemetryBatch, } from "./relay.js";
 export { TraceContext, currentTraceContext, externalTrace, traceLinks } from "./trace-context.js";
 export { pendingSpan } from "./pending-span.js";
+export { makeOwnershipAccounting, measuredSpan, owned, ownedBy, ownerAttribute, type Owner, type SpanMeasure, } from "./ownership.js";
 export { recordWorkerMeasurements } from "./measurements.js";
 export { allowlistedSpans, httpSpanAttributeAllowlist, spanAttributeAllowed, } from "./span-attributes.js";

package/types/telemetry/src/ownership.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Who a span's work belongs to, and how a measured span's time divides among them. A span that
+ * starts work for someone other than its caller declares the owner with `ownedBy`; any other span
+ * works for whoever its parent works for. Each instant then belongs to the innermost boundary in
+ * progress, so Executor's work inside an upstream session stays Executor's, and an app's callback
+ * inside Executor's cache stays the app's.
+ *
+ * Workers clocks advance only on I/O, so durations are comparable within one isolate and not across
+ * isolates: each isolate measures its own part, and the spans that already bracket the work define
+ * it, so the accounting and the trace agree.
+ */
+import { Context, Effect, Tracer } from "effect";
+/**
+ * Executor's own work; the app's authored code; waiting on an upstream provider; or waiting on a
+ * person's answer.
+ */
+export type Owner = "executor" | "app" | "upstream" | "person";
+/** The attribute that shows a boundary's owner in the trace; the telemetry tracer sets it. */
+export declare const ownerAttribute = "executor.owner";
+/** The owner a span declared when it started, if it is an ownership boundary. */
+export declare const declaredOwner: (annotations: Context.Context<never>) => Owner | undefined;
+/**
+ * Options for a span whose work belongs to `owner`. Every ownership boundary uses them, at the point
+ * the work starts: provider requests and sessions are the upstream's, Executor's services called by
+ * an app are Executor's, an app's callbacks are the app's, and waiting for an answer is the person's.
+ */
+export declare const ownedBy: (owner: Owner, options?: Tracer.SpanOptionsNoTrace) => Tracer.SpanOptionsNoTrace;
+/** Run `effect` in span `name`, owned by `owner`. */
+export declare const owned: (owner: Owner, name: string, options?: Tracer.SpanOptionsNoTrace) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+/** What a measured span does with its work and its end. */
+export interface SpanMeasure {
+    /** Wraps the work inside the span, for example to observe the spans it opens. */
+    readonly around?: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+    /** Receives the span's end, before the span ends, to record what it measured on it. */
+    readonly end: (end: bigint, span: Tracer.Span) => void;
+}
+/**
+ * Run `effect` in span `name`, measured by `measure` from the span's own start to its own end, so
+ * the span's duration and the measurement share both boundaries.
+ */
+export declare const measuredSpan: (name: string, options: Tracer.SpanOptionsNoTrace, measure: (start: bigint) => SpanMeasure) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+/**
+ * Divide a window that starts at `origin`, whose own work is `owner`'s, among owners. At each
+ * instant, the work in progress is the innermost span of each branch: a span with no child still
+ * open. Its owner takes the instant. With nothing open inside the window, `owner` takes it. Spans
+ * are counted as they open and end, in constant time each, and only spans still open are kept.
+ */
+export declare const makeOwnershipAccounting: (origin: bigint, owner: Owner) => {
+    /** Run `effect` with the spans it opens observed, including spans it hands to later work. */
+    observe: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+    /**
+     * 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: bigint) => Readonly<Record<Owner, number>>;
+};

package/js/chunk-646JVUH4.js

@@ -1,156 +0,0 @@
-import {
-  declaredOperations,
-  fromPromise,
-  nativeOperation,
-  nativeRouter
-} from "./chunk-OTGUPKKK.js";
-import {
-  ScheduleTiming
-} from "./chunk-ELO5PRCO.js";
-import {
-  decoderOf,
-  isSchema,
-  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 },
-    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
-    })
-  }
-});
-var nativeWorkflow = (value) => {
-  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
-  return value[NativeWorkflow];
-};
-
-// 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 ? {} : {
-    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) },
-          ..."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);
-  const native = {
-    accounts: requirements.accounts,
-    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,
-  isApp,
-  toEffectApp,
-  defineApp
-};

package/js/{chunk-LNSVJS2Q.js → chunk-EOPQ727L.js}

@@ -4392,8 +4392,6 @@ export {
   bodyFormData,
   HttpClientRequest_exports,
   fromWeb2 as fromWeb,
-  HttpServerResponse_exports,
-  HttpServerRequest_exports,
   HttpTraceContext_exports,
   HttpClient,
   transformResponse,
@@ -4406,6 +4404,8 @@ export {
   TracerPropagationEnabled,
   layerMergedContext,
   HttpClient_exports,
+  HttpServerResponse_exports,
+  HttpServerRequest_exports,
   prefixPath,
   fromLiteral
 };