apps 0.0.1-beta.5 → 0.0.1-beta.55

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/types/telemetry/src/recorded-failure.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Failures as Executor's telemetry records them. Traces and error reports keep an error's text only
+ * when Executor wrote it: a tagged error is recorded by its tag and the fixed sentence it declares
+ * (see `RecordedMessage`), or by its tag alone when it declares none. Its fields, message, stack and
+ * cause are not recorded, so a value an error carries for its caller, an app's text or a service's
+ * reply cannot reach telemetry by an error forgetting to declare. The error itself, and what its
+ * caller receives, are unchanged.
+ */
+import { Cause } from "effect";
+/**
+ * The error a trace or error report records in place of `error`.
+ *
+ * - A tagged error is named by its tag: a field called `name`, such as a requested skill's or an
+ *   app's, replaces the error's own name. Its message is the sentence it declares, or empty. Its
+ *   stack is generated here and names no frames: the error's own stack begins with its message,
+ *   which can span lines that look like frames. Traces still show where it failed through the
+ *   operation's own spans, which Effect appends to a recorded stack.
+ * - Any other value that is not an `Error`, such as a plain object Effect would print as JSON, is
+ *   recorded as `UnrecognizedFailure` with no text.
+ * - An untagged `Error` is a defect or a platform's error: its message and stack come from the
+ *   JavaScript engine or a library and are kept, as they are the only diagnosis of an Executor bug.
+ *   Its cause is recorded by these same rules.
+ */
+export declare const recordedError: (error: unknown) => unknown;
+/**
+ * A failure's cause as traces record it: each failure and defect by `recordedError`. Interruptions
+ * are unchanged, and each reason keeps its annotations, which locate it.
+ */
+export declare const recordedCause: <E>(cause: Cause.Cause<E>) => Cause.Cause<unknown>;

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

@@ -23,6 +23,6 @@ export declare const collectTelemetry: <A, E, R>(effect: Effect.Effect<A, E, R>)
         logs: string[];
         dropped: number;
     };
-}, E, Exclude<Exclude<R, import("effect/unstable/observability/OtlpExporter").Flusher>, never>>;
+}, E, Exclude<Exclude<R, import("effect/observability/OtlpExporter").Flusher>, never>>;
 /** Validate isolated records and export only this call's trace, using parent-owned credentials/identity. */
-export declare const forwardTelemetry: (batch: TelemetryBatch, traceId: string | undefined, build: string | undefined, service?: "executor-app" | "executor-web") => Effect.Effect<void, Schema.SchemaError | import("effect/unstable/http/HttpClientError").HttpClientError | import("effect/Cause").TimeoutError, never>;
+export declare const forwardTelemetry: (batch: TelemetryBatch, traceId: string | undefined, build: string | undefined, service?: "executor-app" | "executor-web") => Effect.Effect<void, Schema.SchemaError | import("effect/http/HttpClientError").HttpClientError | import("effect/Cause").TimeoutError, never>;

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

@@ -1,6 +1,13 @@
 import { Context, Layer } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient, HttpClientError } from "effect/http";
 /** Local collector discovery can resolve its destination when an export runs. */
 export declare const CurrentTelemetryClient: Context.Reference<HttpClient.HttpClient | undefined>;
 /** Telemetry consumers inspect status and headers; release response I/O inside each export scope. */
 export declare const telemetryHttpClient: Layer.Layer<HttpClient.HttpClient, never, never>;
+/**
+ * Resend an export the collector refused for now, as OTLP requires and Effect's own
+ * exporters do: lost connections, 429 and 5xx overload, at most three more times. A
+ * collector shedding load answers 429 or 503 with Retry-After, which sets the wait. A
+ * wait longer than the caller's budget ends with the budget, without sending again.
+ */
+export declare const retryTelemetryExport: (client: HttpClient.HttpClient) => HttpClient.HttpClient.With<HttpClientError.HttpClientError, never>;

package/types/utils/src/api-error.d.ts

@@ -0,0 +1,55 @@
+import { Schema, type Cause } from "effect";
+import "effect/http-api";
+/**
+ * Encode the class's `message` getter as a required wire string. Decoding validates the field,
+ * then omits it, so the class derives its own message from the parsed payload and a supplied
+ * value never replaces it.
+ */
+export declare const MessageField: Schema.decodeTo<Schema.optionalKey<Schema.String>, Schema.String, never, never>;
+/** An expected API error whose response states its cause in a `message` derived from its fields. */
+export interface ApiError extends Cause.YieldableError {
+    readonly _tag: string;
+}
+type Header<Tag extends string> = {
+    readonly tag: Tag;
+    readonly status: number;
+};
+type Definition<Tag extends string, Fields extends Schema.Struct.Fields> = Header<Tag> & {
+    readonly fields: Fields & {
+        readonly [Key in "_tag" | "message"]?: never;
+    };
+    /**
+     * The cause, stated for API and agent callers. It is also the error's `message`, which traces
+     * record, so it never includes credentials, upstream response text or submitted values.
+     */
+    readonly message: string | ((fields: Schema.Struct.Type<Fields>) => string);
+    /**
+     * What traces and error reports record beside the tag. A fixed `message` is recorded as is; a
+     * message derived from fields is recorded only through this, from fixed text and closed fields,
+     * never a value the caller chose, an app's text or a service's reply. Without it the error is
+     * recorded by its tag alone.
+     */
+    readonly recorded?: (fields: Schema.Struct.Type<Fields>) => string;
+};
+type ErrorFields<Tag extends string, Fields extends Schema.Struct.Fields> = Omit<Schema.TaggedStruct<Tag, Fields & {
+    readonly message: typeof MessageField;
+}>, "~type.make.in"> & {
+    readonly "~type.make.in": Schema.TaggedStruct<Tag, Fields>["~type.make.in"];
+};
+type ErrorClass<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<Schema.Struct.Type<Fields> & ApiError & {
+    readonly _tag: Tag;
+}, ErrorFields<Tag, Fields>, ApiError>;
+/** Define an error with no payload and a fixed message. Its tag is its public error code. */
+declare function define<const Tag extends string>(definition: Header<Tag> & {
+    readonly message: string;
+}): ErrorClass<Tag, {}>;
+/** Define an error whose message can depend on its parsed fields. */
+declare function define<const Tag extends string, const Fields extends Schema.Struct.Fields>(definition: Definition<Tag, Fields>): ErrorClass<Tag, Fields>;
+/**
+ * Define the schema, constructor and API message of an expected error together. Errors that need
+ * a user-facing title and recovery use `UserFacingError`, which carries the same message field.
+ */
+export declare const ApiError: {
+    define: typeof define;
+};
+export {};

package/types/utils/src/connection-failure.d.ts

@@ -0,0 +1,33 @@
+/** Requests the browser could not complete because no response reached it. */
+import { Cause } from "effect";
+import { HttpClientError } from "effect/http";
+import { UserFacingError } from "./user-facing-error.js";
+/**
+ * Fetch rejects with a `TypeError` when no response arrives: the device is offline, the page
+ * navigated away first, the connection was reset before a response, or the browser blocked the
+ * request. The server may still have completed the request and records its own outcome. Failures Executor constructs itself, such as a batch reply
+ * that ended without an answer, carry no such cause and stay unexpected.
+ */
+export declare const isConnectionFailure: (error: unknown) => error is HttpClientError.HttpClientError;
+/** Typed API clients may surface a lost connection as a failure or, after narrowing, a defect. */
+export declare const hasConnectionFailure: (cause: Cause.Cause<unknown>) => boolean;
+/** The browser could not reach Executor. Nothing on the server needs fixing. */
+export declare const ConnectionFailed: import("effect/Schema").Class<{} & UserFacingError & {
+    readonly _tag: "ConnectionFailed";
+}, Omit<import("effect/Schema").TaggedStruct<"ConnectionFailed", {
+    readonly message: typeof import("./api-error.js").MessageField;
+    readonly recovery: import("effect/Schema").decodeTo<import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly action: import("effect/Schema").String;
+        readonly instructions: import("effect/Schema").String;
+    }>>, import("effect/Schema").Struct<{
+        readonly action: import("effect/Schema").String;
+        readonly instructions: import("effect/Schema").String;
+    }>, never, never>;
+}>, "~type.make.in"> & {
+    readonly "~type.make.in": {
+        readonly _tag?: "ConnectionFailed";
+    };
+}, UserFacingError>;
+export type ConnectionFailed = typeof ConnectionFailed.Type;
+/** What to show for a failure no contract declares: a lost connection, or an unexpected error. */
+export declare const undeclaredError: (cause: Cause.Cause<unknown>) => UserFacingError;

package/types/utils/src/recorded-message.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The fixed sentence traces and error reports record for a tagged error, beside its tag. Telemetry
+ * records no other text from a tagged error: one that declares no sentence is recorded by its tag
+ * alone (`@executor-js/telemetry/recorded-failure`). Declare one from fixed text and closed fields
+ * only, never from a value the caller supplied (a slug, a name, a tool name, an argument's key),
+ * an app's own text or a service's reply. That text still reaches the caller the error is for.
+ * `ApiError` and `UserFacingError` declare a fixed message for you; a message derived from fields
+ * declares `recorded`.
+ */
+export declare const RecordedMessage: unique symbol;
+/** The fixed sentence an error declares for telemetry, if it declares one. */
+export declare const recordedMessage: (error: unknown) => string | undefined;
+/**
+ * Declare a recorded message on one error that Executor did not define the text of, such as an
+ * error decoded from an app's reply. An error class's own declaration is kept. The error's fields
+ * and wire encoding are unchanged.
+ */
+export declare const recordAs: <E>(error: E, message: string) => E;

package/types/utils/src/user-facing-error.d.ts

@@ -0,0 +1,83 @@
+import { Schema, type Cause } from "effect";
+import "effect/http-api";
+import { MessageField } from "./api-error.js";
+/** Curated explanation and recovery. Never include raw diagnostics, credentials, or form values. */
+export interface ErrorPresentation {
+    readonly title: string;
+    readonly description: string;
+    readonly recovery: {
+        readonly action: string;
+        readonly instructions: string;
+    };
+    /** Repeating the failed operation can help. Configuration changes are not retries. */
+    readonly retryable?: boolean;
+    /** False when the user's agent cannot act on the fix prompt, so hosts do not offer it. */
+    readonly agentFixable?: boolean;
+    /** One safe value the user needs for recovery, such as a URL to send to the service. */
+    readonly detail?: {
+        readonly label: string;
+        readonly value: string;
+    };
+    /**
+     * Present only when the Executor team must fix the problem. Safe evidence for a public
+     * report: fixed codes and statuses, never user data, URLs, or upstream text.
+     */
+    readonly report?: string;
+}
+type PresentationProperties = Required<Omit<ErrorPresentation, "detail" | "report">> & {
+    readonly detail: ErrorPresentation["detail"];
+    readonly report: ErrorPresentation["report"];
+    readonly code: string;
+    readonly fixPrompt: string;
+};
+/** A yieldable error that owns its safe user explanation and agent recovery task. */
+export interface UserFacingError extends Cause.YieldableError, PresentationProperties {
+    readonly _tag: string;
+}
+type Header<Tag extends string> = {
+    readonly tag: Tag;
+    readonly status: number;
+};
+type Definition<Tag extends string, Fields extends Schema.Struct.Fields> = Header<Tag> & {
+    readonly fields: Fields & {
+        readonly [Key in keyof PresentationProperties | "_tag" | "message"]?: never;
+    };
+    /**
+     * What traces and error reports record beside the tag. A fixed description is recorded as is; a
+     * presentation derived from fields is recorded only through this, from fixed text and closed
+     * fields, never a value the caller chose, an app's text or a service's reply. Without it the
+     * error is recorded by its tag alone.
+     */
+    readonly recorded?: (fields: Schema.Struct.Type<Fields>) => string;
+} & (ErrorPresentation | {
+    readonly presentation: (fields: Schema.Struct.Type<Fields>) => ErrorPresentation;
+});
+declare const RecoveryField: Schema.decodeTo<Schema.optionalKey<Schema.Struct<{
+    readonly action: Schema.String;
+    readonly instructions: Schema.String;
+}>>, Schema.Struct<{
+    readonly action: Schema.String;
+    readonly instructions: Schema.String;
+}>, never, never>;
+type DerivedFields = {
+    readonly message: typeof MessageField;
+    readonly recovery: typeof RecoveryField;
+};
+type ErrorFields<Tag extends string, Fields extends Schema.Struct.Fields> = Omit<Schema.TaggedStruct<Tag, Fields & DerivedFields>, "~type.make.in"> & {
+    readonly "~type.make.in": Schema.TaggedStruct<Tag, Fields>["~type.make.in"];
+};
+type ErrorClass<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<Schema.Struct.Type<Fields> & UserFacingError & {
+    readonly _tag: Tag;
+}, ErrorFields<Tag, Fields>, UserFacingError>;
+/** Define a schema-backed error with no payload. Its tag becomes its public error code. */
+declare function define<const Tag extends string>(definition: Header<Tag> & ErrorPresentation): ErrorClass<Tag, {}>;
+/** Define a schema-backed error whose safe presentation can depend on its parsed fields. */
+declare function define<const Tag extends string, const Fields extends Schema.Struct.Fields>(definition: Definition<Tag, Fields>): ErrorClass<Tag, Fields>;
+/** Define the schema, error constructor, user copy, and agent recovery together. */
+export declare const UserFacingError: {
+    define: typeof define;
+    is: (value: unknown) => value is UserFacingError;
+};
+/** Defects get a safe explanation without exposing an arbitrary cause. */
+export declare const UnexpectedError: ErrorClass<"UnexpectedError", {}>;
+export {};

package/js/chunk-3XKZDQLM.js

@@ -1,93 +0,0 @@
-import {
-  decoderOf
-} from "./chunk-FWQC6I3C.js";
-import {
-  Effect_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/implementation/authoring.ts
-var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
-var fromPromise = (callback) => (...args) => {
-  if (NativeCallback in callback) {
-    const native = callback[NativeCallback];
-    return native(...args);
-  }
-  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error });
-};
-var toPromise = (operation, signal) => {
-  const native = (...args) => Effect_exports.suspend(() => {
-    if (signal === void 0) return operation(...args);
-    if (signal.aborted) return Effect_exports.interrupt;
-    const cancelled = Effect_exports.callback((resume) => {
-      if (signal.aborted) {
-        resume(Effect_exports.interrupt);
-        return;
-      }
-      const abort = () => resume(Effect_exports.interrupt);
-      signal.addEventListener("abort", abort, { once: true });
-      return Effect_exports.sync(() => signal.removeEventListener("abort", abort));
-    });
-    return Effect_exports.raceFirst(
-      cancelled,
-      Effect_exports.suspend(() => operation(...args))
-    );
-  });
-  return Object.assign((...args) => Effect_exports.runPromise(native(...args)), {
-    [NativeCallback]: native
-  });
-};
-
-// src/implementation/operations.ts
-var NativeOperation = /* @__PURE__ */ Symbol("apps.Operation");
-var operationDeclaration = (operation) => ({
-  kind: operation.kind,
-  [NativeOperation]: operation
-});
-var nativeOperation = (value) => {
-  if (typeof value !== "object" || value === null || !(NativeOperation in value)) return void 0;
-  return value[NativeOperation];
-};
-var operationOptions = (options) => {
-  const approval = options.approval;
-  return {
-    ...options.description === void 0 ? {} : { description: options.description },
-    ...options.title === void 0 ? {} : { title: options.title },
-    ...options.annotations === void 0 ? {} : { annotations: options.annotations },
-    ...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 })
-    }
-  };
-};
-var withApproval = (operation, approval) => ({
-  ...operation,
-  [NativeOperation]: {
-    ...operation[NativeOperation],
-    approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
-  }
-});
-var make = (kind, options, run) => operationDeclaration({
-  ...operationOptions(options),
-  kind,
-  // The host always validates JSON serialization, even without a stronger output declaration.
-  ...options.output === void 0 ? {} : { output: decoderOf(options.output) },
-  run: (context, input) => Effect_exports.tryPromise({
-    // SAFETY: defineApp checks the handler context against its requirements.
-    // The host validates account bindings and creates the matching storage facade.
-    try: () => run(context, input),
-    catch: (error) => error
-  })
-});
-var query = (options, run) => make("query", options, run);
-var mutation = (options, run) => make("mutation", options, run);
-
-export {
-  fromPromise,
-  toPromise,
-  operationDeclaration,
-  nativeOperation,
-  withApproval,
-  query,
-  mutation
-};

package/js/chunk-4M277YTM.js

@@ -1,136 +0,0 @@
-import {
-  ApiErrorResponse
-} from "./chunk-W4DMKWAB.js";
-import {
-  AccountId,
-  HttpUrl,
-  JsonObject
-} from "./chunk-27F7W2LG.js";
-import {
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/contracts/openapi.ts
-var OpenapiErrorResponse = Schema_exports.Struct({
-  code: ApiErrorResponse.fields.code,
-  status: ApiErrorResponse.fields.status,
-  message: Schema_exports.Union([
-    Schema_exports.Struct({ source: Schema_exports.Literal("body") }),
-    Schema_exports.Struct({ source: Schema_exports.Literal("schema"), value: ApiErrorResponse.fields.message })
-  ]),
-  schema: JsonObject
-});
-var OpenapiParameter = Schema_exports.Struct({
-  name: Schema_exports.String,
-  in: Schema_exports.Literals(["path", "query", "header", "cookie"]),
-  required: Schema_exports.optionalKey(Schema_exports.Boolean),
-  schema: Schema_exports.optionalKey(JsonObject),
-  style: Schema_exports.optionalKey(Schema_exports.String),
-  explode: Schema_exports.optionalKey(Schema_exports.Boolean),
-  allowReserved: Schema_exports.optionalKey(Schema_exports.Boolean),
-  allowEmptyValue: Schema_exports.optionalKey(Schema_exports.Boolean),
-  content: Schema_exports.optionalKey(JsonObject)
-});
-var OpenapiRequestBody = Schema_exports.Struct({
-  required: Schema_exports.optionalKey(Schema_exports.Boolean),
-  content: Schema_exports.Record(
-    Schema_exports.String,
-    Schema_exports.Struct({
-      schema: Schema_exports.optionalKey(JsonObject),
-      encoding: Schema_exports.optionalKey(JsonObject)
-    })
-  )
-});
-var OpenapiOperation = Schema_exports.Struct({
-  /** The tool name after `queries.` or `mutations.`, grouped as `<group>.<leaf>`. */
-  name: Schema_exports.NonEmptyString,
-  /** The document's operationId, when it declares one. `kinds` overrides are keyed by it. */
-  operationId: Schema_exports.optionalKey(Schema_exports.String),
-  description: Schema_exports.String,
-  method: Schema_exports.Literals(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]),
-  path: Schema_exports.String,
-  baseUrl: HttpUrl,
-  openapi: Schema_exports.String,
-  securitySchemes: Schema_exports.Record(Schema_exports.String, JsonObject),
-  /** The resolved OpenAPI Operation Object; Executor schemas remain separate. */
-  request: Schema_exports.Struct({
-    parameters: Schema_exports.Array(OpenapiParameter),
-    requestBody: Schema_exports.optionalKey(OpenapiRequestBody),
-    security: Schema_exports.Array(Schema_exports.Record(Schema_exports.String, Schema_exports.Array(Schema_exports.String))),
-    responses: Schema_exports.Record(Schema_exports.String, JsonObject)
-  }),
-  /** Streams remain in the metadata but cannot run through a single-result tool call. */
-  streaming: Schema_exports.optionalKey(Schema_exports.Literal(true)),
-  input: JsonObject,
-  outputSchema: Schema_exports.optionalKey(JsonObject),
-  errorResponses: Schema_exports.optionalKey(Schema_exports.Array(OpenapiErrorResponse))
-});
-var CredentialBinding = Schema_exports.Struct({
-  scheme: Schema_exports.String,
-  field: Schema_exports.String,
-  part: Schema_exports.Literals(["value", "username", "password"]),
-  prefix: Schema_exports.String
-});
-var OpenapiAccount = Schema_exports.Struct({
-  id: Schema_exports.optional(AccountId),
-  method: Schema_exports.String,
-  fields: Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
-});
-var OpenapiParameterDefaults = Schema_exports.Struct({
-  path: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
-  query: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
-  headers: Schema_exports.optionalKey(Schema_exports.Record(Schema_exports.String, Schema_exports.String))
-});
-var OpenapiToolsOptions = Schema_exports.Struct({
-  operations: Schema_exports.Array(OpenapiOperation),
-  /**
-   * Component schemas stored once per app and referenced as `#/$defs/<name>`. Operations
-   * generated before shared definitions carry their own `$defs` and omit this.
-   */
-  definitions: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, JsonObject)),
-  methods: Schema_exports.Record(Schema_exports.String, Schema_exports.Array(CredentialBinding)),
-  oauth: Schema_exports.Array(Schema_exports.String),
-  account: Schema_exports.optional(OpenapiAccount),
-  parameterDefaults: Schema_exports.optional(OpenapiParameterDefaults),
-  signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
-  fetch: Schema_exports.optional(
-    Schema_exports.declare((value) => typeof value === "function")
-  )
-});
-var OpenapiError = class extends Schema_exports.TaggedError()("OpenapiError", {
-  reason: Schema_exports.Literals(["invalid_definition", "invalid_input", "request"]),
-  status: Schema_exports.optional(Schema_exports.Number)
-}) {
-};
-var defaultOpenapiResponseLimits = {
-  maxBodyBytes: 16777216,
-  readTimeoutMs: 3e4
-};
-var isOpenapiTextMedia = (type) => /^(?:text\/|application\/(?:[\w.-]+\+)?(?:json|xml)|application\/(?:javascript|x-ndjson|x-www-form-urlencoded))/i.test(
-  type
-);
-var isOpenapiFileSchema = (shape) => shape.contentMediaType !== void 0 && shape.contentEncoding === void 0 || shape.type === "string" && shape.format === "binary";
-var openapiBinaryResultSchema = {
-  type: "object",
-  properties: {
-    base64: { type: "string", contentEncoding: "base64" },
-    contentType: { type: "string" }
-  },
-  required: ["base64", "contentType"],
-  additionalProperties: false
-};
-var openapiMediaKind = (type) => type.includes("json") && !type.includes("ndjson") ? "json" : type === "application/x-www-form-urlencoded" ? "form" : type === "multipart/form-data" ? "multipart" : isOpenapiTextMedia(type) ? "text" : "binary";
-
-export {
-  OpenapiErrorResponse,
-  OpenapiParameter,
-  OpenapiRequestBody,
-  OpenapiOperation,
-  OpenapiToolsOptions,
-  OpenapiError,
-  defaultOpenapiResponseLimits,
-  isOpenapiTextMedia,
-  isOpenapiFileSchema,
-  openapiBinaryResultSchema,
-  openapiMediaKind
-};