@lifi/composer-sdk 0.7.1 → 0.9.0

package/dist/discovery.d.cts

@@ -1,3 +1,4 @@
+//#region src/discovery.d.ts
 /**
  * Types for the Compose discovery API (`GET /compose/zap-packs`, `GET /chains`).
  *
@@ -13,73 +14,73 @@
 /**
  * A chain the Compose deployment supports.
  */
-interface ChainSummary {
-    /** EVM chain ID. The stable identifier — key on this. */
-    readonly chainId: number;
-    /**
-     * Human-readable label, suitable for display in a chain selector.
-     *
-     * Maintained by the deployment rather than derived from canonical chain
-     * branding, so it can differ from a chain's marketed name and can change
-     * without notice. Never treat it as an identifier, and never match on it.
-     * A chain the deployment has no configured label for reports `Chain <id>`.
-     */
-    readonly name: string;
+export interface ChainSummary {
+  /** EVM chain ID. The stable identifier — key on this. */
+  readonly chainId: number;
+  /**
+   * Human-readable label, suitable for display in a chain selector.
+   *
+   * Maintained by the deployment rather than derived from canonical chain
+   * branding, so it can differ from a chain's marketed name and can change
+   * without notice. Never treat it as an identifier, and never match on it.
+   * A chain the deployment has no configured label for reports `Chain <id>`.
+   */
+  readonly name: string;
 }
 /**
  * A single routing edge representing a supported token-to-token path
  * through a DeFi protocol.
  */
-interface ZapPackEdge {
-    /** Edge type (e.g. `"enter-position"`, `"exit-position"`, `"wrap"`). */
-    readonly type: string;
-    /** Input token. */
-    readonly in: {
-        readonly address: string;
-        readonly chainId: number;
-    };
-    /** Output token. */
-    readonly out: {
-        readonly address: string;
-        readonly chainId: number;
-    };
-    /** Minimum input amount accepted (stringified integer), if constrained. */
-    readonly inAmountMin?: string;
-    /** Maximum input amount accepted (stringified integer), if constrained. */
-    readonly inAmountMax?: string;
-    /**
-     * Recipient binding obligation. `"required"` means the zap must bind its
-     * `recipient` input. The output is externally owned, terminal, and unswept.
-     * The loose string type preserves forward compatibility with new values.
-     */
-    readonly recipient?: string;
-    /**
-     * Output availability. `"future"` means the output becomes available only
-     * after the initiating transaction settles; route via `lifi.zapAsync` with
-     * a bound recipient. Absent means the output is available synchronously.
-     * The loose string type preserves forward compatibility with new values.
-     */
-    readonly availability?: string;
+export interface ZapPackEdge {
+  /** Edge type (e.g. `"enter-position"`, `"exit-position"`, `"wrap"`). */
+  readonly type: string;
+  /** Input token. */
+  readonly in: {
+    readonly address: string;
+    readonly chainId: number;
+  };
+  /** Output token. */
+  readonly out: {
+    readonly address: string;
+    readonly chainId: number;
+  };
+  /** Minimum input amount accepted (stringified integer), if constrained. */
+  readonly inAmountMin?: string;
+  /** Maximum input amount accepted (stringified integer), if constrained. */
+  readonly inAmountMax?: string;
+  /**
+   * Recipient binding obligation. `"required"` means the zap must bind its
+   * `recipient` input. The output is externally owned, terminal, and unswept.
+   * The loose string type preserves forward compatibility with new values.
+   */
+  readonly recipient?: string;
+  /**
+   * Output availability. `"future"` means the output becomes available only
+   * after the initiating transaction settles; route via `lifi.zapAsync` with
+   * a bound recipient. Absent means the output is available synchronously.
+   * The loose string type preserves forward compatibility with new values.
+   */
+  readonly availability?: string;
 }
 /**
  * All routing edges for a single protocol.
  */
-interface ZapPackOverview {
-    /** Protocol identifier (e.g. `"aave"`, `"morpho"`). */
-    readonly protocol: string;
-    /** Available routing edges for this protocol. */
-    readonly edges: readonly ZapPackEdge[];
+export interface ZapPackOverview {
+  /** Protocol identifier (e.g. `"aave"`, `"morpho"`). */
+  readonly protocol: string;
+  /** Available routing edges for this protocol. */
+  readonly edges: readonly ZapPackEdge[];
 }
 /**
  * Options for {@link ComposeClient.getZapPacks}.
  */
-interface GetZapPacksOptions {
-    /**
-     * Filter to specific protocols. Pass a single string or an array.
-     * Only edges belonging to the listed protocols are returned.
-     * Omit to fetch all available protocols.
-     */
-    readonly protocols?: string | readonly string[];
+export interface GetZapPacksOptions {
+  /**
+   * Filter to specific protocols. Pass a single string or an array.
+   * Only edges belonging to the listed protocols are returned.
+   * Omit to fetch all available protocols.
+   */
+  readonly protocols?: string | readonly string[];
 }
-
-export type { ChainSummary, GetZapPacksOptions, ZapPackEdge, ZapPackOverview };
+//#endregion
+//# sourceMappingURL=discovery.d.cts.map

package/dist/discovery.d.ts

@@ -1,3 +1,4 @@
+//#region src/discovery.d.ts
 /**
  * Types for the Compose discovery API (`GET /compose/zap-packs`, `GET /chains`).
  *
@@ -13,73 +14,73 @@
 /**
  * A chain the Compose deployment supports.
  */
-interface ChainSummary {
-    /** EVM chain ID. The stable identifier — key on this. */
-    readonly chainId: number;
-    /**
-     * Human-readable label, suitable for display in a chain selector.
-     *
-     * Maintained by the deployment rather than derived from canonical chain
-     * branding, so it can differ from a chain's marketed name and can change
-     * without notice. Never treat it as an identifier, and never match on it.
-     * A chain the deployment has no configured label for reports `Chain <id>`.
-     */
-    readonly name: string;
+export interface ChainSummary {
+  /** EVM chain ID. The stable identifier — key on this. */
+  readonly chainId: number;
+  /**
+   * Human-readable label, suitable for display in a chain selector.
+   *
+   * Maintained by the deployment rather than derived from canonical chain
+   * branding, so it can differ from a chain's marketed name and can change
+   * without notice. Never treat it as an identifier, and never match on it.
+   * A chain the deployment has no configured label for reports `Chain <id>`.
+   */
+  readonly name: string;
 }
 /**
  * A single routing edge representing a supported token-to-token path
  * through a DeFi protocol.
  */
-interface ZapPackEdge {
-    /** Edge type (e.g. `"enter-position"`, `"exit-position"`, `"wrap"`). */
-    readonly type: string;
-    /** Input token. */
-    readonly in: {
-        readonly address: string;
-        readonly chainId: number;
-    };
-    /** Output token. */
-    readonly out: {
-        readonly address: string;
-        readonly chainId: number;
-    };
-    /** Minimum input amount accepted (stringified integer), if constrained. */
-    readonly inAmountMin?: string;
-    /** Maximum input amount accepted (stringified integer), if constrained. */
-    readonly inAmountMax?: string;
-    /**
-     * Recipient binding obligation. `"required"` means the zap must bind its
-     * `recipient` input. The output is externally owned, terminal, and unswept.
-     * The loose string type preserves forward compatibility with new values.
-     */
-    readonly recipient?: string;
-    /**
-     * Output availability. `"future"` means the output becomes available only
-     * after the initiating transaction settles; route via `lifi.zapAsync` with
-     * a bound recipient. Absent means the output is available synchronously.
-     * The loose string type preserves forward compatibility with new values.
-     */
-    readonly availability?: string;
+export interface ZapPackEdge {
+  /** Edge type (e.g. `"enter-position"`, `"exit-position"`, `"wrap"`). */
+  readonly type: string;
+  /** Input token. */
+  readonly in: {
+    readonly address: string;
+    readonly chainId: number;
+  };
+  /** Output token. */
+  readonly out: {
+    readonly address: string;
+    readonly chainId: number;
+  };
+  /** Minimum input amount accepted (stringified integer), if constrained. */
+  readonly inAmountMin?: string;
+  /** Maximum input amount accepted (stringified integer), if constrained. */
+  readonly inAmountMax?: string;
+  /**
+   * Recipient binding obligation. `"required"` means the zap must bind its
+   * `recipient` input. The output is externally owned, terminal, and unswept.
+   * The loose string type preserves forward compatibility with new values.
+   */
+  readonly recipient?: string;
+  /**
+   * Output availability. `"future"` means the output becomes available only
+   * after the initiating transaction settles; route via `lifi.zapAsync` with
+   * a bound recipient. Absent means the output is available synchronously.
+   * The loose string type preserves forward compatibility with new values.
+   */
+  readonly availability?: string;
 }
 /**
  * All routing edges for a single protocol.
  */
-interface ZapPackOverview {
-    /** Protocol identifier (e.g. `"aave"`, `"morpho"`). */
-    readonly protocol: string;
-    /** Available routing edges for this protocol. */
-    readonly edges: readonly ZapPackEdge[];
+export interface ZapPackOverview {
+  /** Protocol identifier (e.g. `"aave"`, `"morpho"`). */
+  readonly protocol: string;
+  /** Available routing edges for this protocol. */
+  readonly edges: readonly ZapPackEdge[];
 }
 /**
  * Options for {@link ComposeClient.getZapPacks}.
  */
-interface GetZapPacksOptions {
-    /**
-     * Filter to specific protocols. Pass a single string or an array.
-     * Only edges belonging to the listed protocols are returned.
-     * Omit to fetch all available protocols.
-     */
-    readonly protocols?: string | readonly string[];
+export interface GetZapPacksOptions {
+  /**
+   * Filter to specific protocols. Pass a single string or an array.
+   * Only edges belonging to the listed protocols are returned.
+   * Omit to fetch all available protocols.
+   */
+  readonly protocols?: string | readonly string[];
 }
-
-export type { ChainSummary, GetZapPacksOptions, ZapPackEdge, ZapPackOverview };
+//#endregion
+//# sourceMappingURL=discovery.d.ts.map

package/dist/discovery.js

@@ -1 +1 @@
-//# sourceMappingURL=discovery.js.map
+export {};

package/dist/errors.cjs

@@ -1,175 +1,227 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_responseSchemas = require("./responseSchemas.cjs");
+let zod = require("zod");
+zod = require_runtime.__toESM(zod, 1);
+//#region src/errors.ts
+/**
+* Error class for all failures originating from the Compose SDK or API.
+*
+* Includes structured metadata beyond the error message to support
+* programmatic error handling.
+*
+* @example
+* ```ts
+* try {
+*   await builder.compile(run);
+* } catch (e) {
+*   if (isComposeError(e) && e.code === 'VALIDATION_ERROR') {
+*     console.error('Invalid request:', e.message, e.path);
+*   }
+* }
+* ```
+*/
+var ComposeError = class extends Error {
+	name = "ComposeError";
+	/** Machine-readable error category. */
+	code;
+	/** HTTP status code, when the error originated from an HTTP response. */
+	status;
+	/** The request URL that produced the error. */
+	url;
+	/** Server-provided error kind for finer-grained classification. */
+	kind;
+	/**
+	* Where a validation error points: the node id for a rejection of an
+	* authored node, or a JSON-pointer path for a rejection of the request shape.
+	*/
+	path;
+	/**
+	* The input port of {@link ComposeError.path}'s node whose binding caused the
+	* error. Set when the rejection is about what a port binds rather than about
+	* the node's config.
+	*/
+	port;
+	/**
+	* The one edit that clears the error, written for whoever authored the flow.
+	* Set on `continuation.settle` authoring rejections; may be absent on other
+	* `validation_error`s.
+	*/
+	fix;
+	/**
+	* Simulation revert diagnostics attached to `simulation_revert` errors.
+	* Contains the raw error bytes and decoded error candidates when the
+	* backend can parse the revert reason.
+	*/
+	details;
+	/**
+	* The prepared ops that failed, attached to `preparation_error` errors.
+	* Each entry carries the `callId` of the failing node so callers can drop
+	* the unroutable legs and resubmit a smaller flow.
+	*/
+	failedOps;
+	/**
+	* The `callId`s of the prepared ops that succeeded, attached to
+	* `preparation_error` errors alongside {@link ComposeError.failedOps}.
+	*/
+	succeededOps;
+	/** Version details attached only to `sdk_outdated` errors. */
+	sdkOutdated;
+	/** Version details attached only to `server_outdated` errors. */
+	serverOutdated;
+	constructor(code, message, options) {
+		super(message, { cause: options?.cause });
+		this.code = code;
+		this.status = options?.status;
+		this.url = options?.url;
+		this.kind = options?.kind;
+		this.path = options?.path;
+		this.port = options?.port;
+		this.fix = options?.fix;
+		this.details = options?.details;
+		this.failedOps = options?.failedOps;
+		this.succeededOps = options?.succeededOps;
+		this.sdkOutdated = options?.sdkOutdated;
+		this.serverOutdated = options?.serverOutdated;
+	}
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var errors_exports = {};
-__export(errors_exports, {
-  ComposeError: () => ComposeError,
-  errorFromHttpResponse: () => errorFromHttpResponse,
-  isComposeError: () => isComposeError,
-  isComposePreparationError: () => isComposePreparationError,
-  isComposeSdkOutdatedError: () => isComposeSdkOutdatedError,
-  isComposeServerOutdatedError: () => isComposeServerOutdatedError
-});
-module.exports = __toCommonJS(errors_exports);
-var import_zod = __toESM(require("zod"), 1);
-var import_responseSchemas = require("./responseSchemas.js");
-class ComposeError extends Error {
-  name = "ComposeError";
-  /** Machine-readable error category. */
-  code;
-  /** HTTP status code, when the error originated from an HTTP response. */
-  status;
-  /** The request URL that produced the error. */
-  url;
-  /** Server-provided error kind for finer-grained classification. */
-  kind;
-  /**
-   * Where a validation error points: the node id for a rejection of an
-   * authored node, or a JSON-pointer path for a rejection of the request shape.
-   */
-  path;
-  /**
-   * The input port of {@link ComposeError.path}'s node whose binding caused the
-   * error. Set when the rejection is about what a port binds rather than about
-   * the node's config.
-   */
-  port;
-  /**
-   * The one edit that clears the error, written for whoever authored the flow.
-   * Set on `continuation.settle` authoring rejections; may be absent on other
-   * `validation_error`s.
-   */
-  fix;
-  /**
-   * Simulation revert diagnostics attached to `simulation_revert` errors.
-   * Contains the raw error bytes and decoded error candidates when the
-   * backend can parse the revert reason.
-   */
-  details;
-  /**
-   * The prepared ops that failed, attached to `preparation_error` errors.
-   * Each entry carries the `callId` of the failing node so callers can drop
-   * the unroutable legs and resubmit a smaller flow.
-   */
-  failedOps;
-  /**
-   * The `callId`s of the prepared ops that succeeded, attached to
-   * `preparation_error` errors alongside {@link ComposeError.failedOps}.
-   */
-  succeededOps;
-  /** Version details attached only to `sdk_outdated` errors. */
-  sdkOutdated;
-  /** Version details attached only to `server_outdated` errors. */
-  serverOutdated;
-  constructor(code, message, options) {
-    super(message, { cause: options?.cause });
-    this.code = code;
-    this.status = options?.status;
-    this.url = options?.url;
-    this.kind = options?.kind;
-    this.path = options?.path;
-    this.port = options?.port;
-    this.fix = options?.fix;
-    this.details = options?.details;
-    this.failedOps = options?.failedOps;
-    this.succeededOps = options?.succeededOps;
-    this.sdkOutdated = options?.sdkOutdated;
-    this.serverOutdated = options?.serverOutdated;
-  }
-}
+/**
+* Type guard that narrows an unknown error to {@link ComposeError}.
+* @param e - The value to check.
+* @returns `true` if `e` is an instance of `ComposeError`.
+*/
 const isComposeError = (e) => e instanceof ComposeError || e instanceof Error && e.name === "ComposeError" && "code" in e;
+/**
+* Type guard for `preparation_error` failures (HTTP 422): a mixed basket where
+* some prepared ops failed and others succeeded. Narrows both
+* {@link ComposeError.failedOps} and {@link ComposeError.succeededOps} to
+* present, so callers can read them without a cast or a truthiness check.
+*
+* @param e - The value to check.
+* @returns `true` if `e` is a `ComposeError` carrying per-op preparation diagnostics.
+*
+* @example
+* ```ts
+* try {
+*   await builder.compile(run);
+* } catch (e) {
+*   if (isComposePreparationError(e)) {
+*     console.error('Failed ops:', e.failedOps);
+*     console.error('Succeeded ops:', e.succeededOps);
+*   }
+* }
+* ```
+*/
 const isComposePreparationError = (e) => isComposeError(e) && e.kind === "preparation_error" && Array.isArray(e.failedOps) && Array.isArray(e.succeededOps);
-const sdkOutdatedSchema = import_zod.default.object({
-  sdkVersion: import_zod.default.string(),
-  serverVersion: import_zod.default.string(),
-  minimumSdkVersion: import_zod.default.string()
+const sdkOutdatedSchema = zod.default.object({
+	sdkVersion: zod.default.string(),
+	serverVersion: zod.default.string(),
+	minimumSdkVersion: zod.default.string()
 });
+/**
+* Narrows an outdated-SDK rejection to its required version details.
+*
+* @example
+* ```ts
+* try {
+*   await builder.compile(run);
+* } catch (e) {
+*   if (isComposeSdkOutdatedError(e)) {
+*     console.error(`Upgrade to at least ${e.sdkOutdated.minimumSdkVersion}`);
+*     return;
+*   }
+*   throw e;
+* }
+* ```
+*/
 const isComposeSdkOutdatedError = (e) => isComposeError(e) && e.kind === "sdk_outdated" && sdkOutdatedSchema.safeParse(e.sdkOutdated).success;
-const serverOutdatedSchema = import_zod.default.object({
-  sdkVersion: import_zod.default.string(),
-  serverVersion: import_zod.default.string()
+const serverOutdatedSchema = zod.default.object({
+	sdkVersion: zod.default.string(),
+	serverVersion: zod.default.string()
 });
+/**
+* Narrows a server-behind-SDK rejection to its required version details.
+*
+* This is the deploy-window error: the SDK on npm is ahead of the backend that
+* answered. Pin the SDK to the server's `major.minor`, or wait for the rollout.
+*
+* @example
+* ```ts
+* try {
+*   await builder.compile(run);
+* } catch (e) {
+*   if (isComposeServerOutdatedError(e)) {
+*     console.error(`Server serves ${e.serverOutdated.serverVersion}`);
+*     return;
+*   }
+*   throw e;
+* }
+* ```
+*/
 const isComposeServerOutdatedError = (e) => isComposeError(e) && e.kind === "server_outdated" && serverOutdatedSchema.safeParse(e.serverOutdated).success;
 const STATUS_TO_CODE = /* @__PURE__ */ new Map([
-  [400, "VALIDATION_ERROR"],
-  [401, "UNAUTHENTICATED"],
-  [403, "FORBIDDEN"],
-  [404, "NOT_FOUND"],
-  [422, "VALIDATION_ERROR"],
-  [429, "RATE_LIMITED"]
+	[400, "VALIDATION_ERROR"],
+	[401, "UNAUTHENTICATED"],
+	[403, "FORBIDDEN"],
+	[404, "NOT_FOUND"],
+	[422, "VALIDATION_ERROR"],
+	[429, "RATE_LIMITED"]
 ]);
 const tryParseErrorBody = (body) => {
-  let json;
-  try {
-    json = JSON.parse(body);
-  } catch {
-    return null;
-  }
-  return (0, import_responseSchemas.parseServerErrorBody)(json);
+	let json;
+	try {
+		json = JSON.parse(body);
+	} catch {
+		return null;
+	}
+	return require_responseSchemas.parseServerErrorBody(json);
 };
+/**
+* Extracts the version triple an `sdk_outdated` or `server_outdated` envelope
+* carries. The slots reuse the same schemas the type guards narrow with. Zod
+* strips keys the schema does not declare, so the parsed value is exactly the
+* triple; a partial payload fails the parse and yields `undefined` rather than
+* a half-populated object.
+*/
 const readVersionSlots = (serverError) => ({
-  sdkOutdated: serverError?.kind === "sdk_outdated" ? sdkOutdatedSchema.safeParse(serverError).data : void 0,
-  serverOutdated: serverError?.kind === "server_outdated" ? serverOutdatedSchema.safeParse(serverError).data : void 0
+	sdkOutdated: serverError?.kind === "sdk_outdated" ? sdkOutdatedSchema.safeParse(serverError).data : void 0,
+	serverOutdated: serverError?.kind === "server_outdated" ? serverOutdatedSchema.safeParse(serverError).data : void 0
 });
+/**
+* Constructs a {@link ComposeError} from an HTTP error response, extracting
+* structured error details from the response body when available.
+*
+* @param status - The HTTP status code.
+* @param body - The raw response body text.
+* @param url - The request URL that produced the error.
+* @returns A `ComposeError` with the appropriate error code and metadata.
+*/
 const errorFromHttpResponse = (status, body, url) => {
-  const parsed = tryParseErrorBody(body);
-  const serverError = parsed?.error;
-  const { sdkOutdated, serverOutdated } = readVersionSlots(serverError);
-  return new ComposeError(
-    STATUS_TO_CODE.get(status) ?? (status >= 500 ? "SERVER_ERROR" : "UNKNOWN_ERROR"),
-    (serverError?.message ?? body) || `HTTP ${status}`,
-    {
-      status,
-      url,
-      kind: serverError?.kind,
-      path: serverError?.path,
-      port: serverError?.port,
-      fix: serverError?.fix,
-      details: serverError?.details,
-      // The wire schema types `kind` as a bare string; the server only ever
-      // reports generic kinds for individual ops.
-      failedOps: serverError?.failedOps?.map((op) => ({
-        ...op,
-        kind: op.kind
-      })),
-      succeededOps: serverError?.succeededOps,
-      sdkOutdated,
-      serverOutdated
-    }
-  );
+	const serverError = tryParseErrorBody(body)?.error;
+	const { sdkOutdated, serverOutdated } = readVersionSlots(serverError);
+	return new ComposeError(STATUS_TO_CODE.get(status) ?? (status >= 500 ? "SERVER_ERROR" : "UNKNOWN_ERROR"), (serverError?.message ?? body) || `HTTP ${status}`, {
+		status,
+		url,
+		kind: serverError?.kind,
+		path: serverError?.path,
+		port: serverError?.port,
+		fix: serverError?.fix,
+		details: serverError?.details,
+		failedOps: serverError?.failedOps?.map((op) => ({
+			...op,
+			kind: op.kind
+		})),
+		succeededOps: serverError?.succeededOps,
+		sdkOutdated,
+		serverOutdated
+	});
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ComposeError,
-  errorFromHttpResponse,
-  isComposeError,
-  isComposePreparationError,
-  isComposeSdkOutdatedError,
-  isComposeServerOutdatedError
-});
+//#endregion
+exports.ComposeError = ComposeError;
+exports.errorFromHttpResponse = errorFromHttpResponse;
+exports.isComposeError = isComposeError;
+exports.isComposePreparationError = isComposePreparationError;
+exports.isComposeSdkOutdatedError = isComposeSdkOutdatedError;
+exports.isComposeServerOutdatedError = isComposeServerOutdatedError;
+
 //# sourceMappingURL=errors.cjs.map