@lifi/composer-sdk 0.8.1 → 0.9.0

package/dist/run/inputs.cjs

@@ -1,53 +1,61 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var inputs_exports = {};
-__export(inputs_exports, {
-  buildRun: () => buildRun,
-  materialiser: () => materialiser
-});
-module.exports = __toCommonJS(inputs_exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/run/inputs.ts
+/**
+* Creates an untyped materialiser input spec. This is a low-level escape hatch
+* for materialiser kinds not yet covered by the generated helpers.
+*
+* Prefer the typed helpers in the `materialisers` namespace (e.g.
+* `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide
+* compile-time config validation.
+*
+* @param kind - The materialiser type (e.g. `"balanceOf"`, `"directDeposit"`).
+* @param config - Optional materialiser-specific configuration.
+* @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.
+*
+* @example
+* ```ts
+* const run = {
+*   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },
+*   signer: '0x...',
+* };
+* ```
+*/
 const materialiser = (kind, config = {}) => ({
-  kind,
-  ...config
+	kind,
+	...config
 });
-const pickDefined = (obj) => Object.fromEntries(
-  Object.entries(obj).filter(([, value]) => value !== void 0)
-);
+/**
+* Drops the keys whose value is `undefined`, so optional fields are omitted
+* from the wire payload rather than serialized as `null`.
+*
+* A local copy of `pickDefined` from `@lifi/utils`: this package is published
+* to npm and `@lifi/utils` is a private workspace package, so it cannot be a
+* runtime dependency here.
+*/
+const pickDefined = (obj) => Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+/**
+* Assembles a {@link ComposeRun} object from individual parameters.
+* Used internally by the SDK; prefer {@link ComposeRunInput} for external use.
+*
+* @internal
+*/
 const buildRun = (run) => ({
-  inputs: run.inputs,
-  signer: run.signer,
-  ...pickDefined({
-    // An empty precondition list is the same as none, so drop it too.
-    preconditions: run.preconditions?.length ? run.preconditions : void 0,
-    assumptions: run.assumptions,
-    referrer: run.referrer,
-    integratorFeeBps: run.integratorFeeBps,
-    maxPriceImpactBps: run.maxPriceImpactBps,
-    sweepTo: run.sweepTo,
-    simulationPolicy: run.simulationPolicy,
-    simulateUserProgram: run.simulateUserProgram,
-    checkOnChainAllowances: run.checkOnChainAllowances
-  })
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildRun,
-  materialiser
+	inputs: run.inputs,
+	signer: run.signer,
+	...pickDefined({
+		preconditions: run.preconditions?.length ? run.preconditions : void 0,
+		assumptions: run.assumptions,
+		referrer: run.referrer,
+		integratorFeeBps: run.integratorFeeBps,
+		maxPriceImpactBps: run.maxPriceImpactBps,
+		sweepTo: run.sweepTo,
+		simulationPolicy: run.simulationPolicy,
+		simulateUserProgram: run.simulateUserProgram,
+		checkOnChainAllowances: run.checkOnChainAllowances
+	})
 });
+//#endregion
+exports.buildRun = buildRun;
+exports.materialiser = materialiser;
+
 //# sourceMappingURL=inputs.cjs.map

package/dist/run/inputs.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    integratorFeeBps: run.integratorFeeBps,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0FO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAUA,MAAM,cAAc,CAClB,QAEA,OAAO;AAAA,EACL,OAAO,QAAQ,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,MAAM,UAAU,MAAS;AAC/D;AAQK,MAAM,WAAW,CAAC,SAYN;AAAA,EACjB,QAAQ,IAAI;AAAA,EACZ,QAAQ,IAAI;AAAA,EACZ,GAAG,YAAY;AAAA;AAAA,IAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB;AAAA,IAC/D,aAAa,IAAI;AAAA,IACjB,UAAU,IAAI;AAAA,IACd,kBAAkB,IAAI;AAAA,IACtB,mBAAmB,IAAI;AAAA,IACvB,SAAS,IAAI;AAAA,IACb,kBAAkB,IAAI;AAAA,IACtB,qBAAqB,IAAI;AAAA,IACzB,wBAAwB,IAAI;AAAA,EAC9B,CAAC;AACH;","names":[]}
+{"version":3,"file":"inputs.cjs","names":[],"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    integratorFeeBps: run.integratorFeeBps,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA0FA,MAAa,gBACX,MACA,SAAkC,CAAC,OACZ;CACvB;CACA,GAAG;AACL;;;;;;;;;AAUA,MAAM,eACJ,QAEA,OAAO,YACL,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAC/D;;;;;;;AAQF,MAAa,YAAY,SAYN;CACjB,QAAQ,IAAI;CACZ,QAAQ,IAAI;CACZ,GAAG,YAAY;EAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB,KAAA;EAC/D,aAAa,IAAI;EACjB,UAAU,IAAI;EACd,kBAAkB,IAAI;EACtB,mBAAmB,IAAI;EACvB,SAAS,IAAI;EACb,kBAAkB,IAAI;EACtB,qBAAqB,IAAI;EACzB,wBAAwB,IAAI;CAC9B,CAAC;AACH"}

package/dist/run/inputs.d.cts

@@ -1,67 +1,63 @@
-import { Precondition, SweepTo, SimulationPolicy, MaterialiserInput, InputSpec, ComposeRun } from '@lifi/compose-spec';
-import { InputSchema, InputSpecOf, Address } from '../types.cjs';
-
+import { Address, InputSchema, InputSpecOf } from "../types.cjs";
+import { ComposeRun, InputSpec, MaterialiserInput, Precondition, SimulationPolicy, SweepTo } from "@lifi/compose-spec";
+//#region src/run/inputs.d.ts
 /**
  * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.
  *
  * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.
  */
-interface ComposeRunInput<T extends InputSchema = InputSchema> {
-    /**
-     * Concrete values for each declared flow input. Resource inputs accept a
-     * materialiser or a literal integer amount; scalar inputs accept the matching type.
-     */
-    readonly inputs: {
-        readonly [K in keyof T]: InputSpecOf<T[K]>;
-    };
-    /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */
-    readonly preconditions?: readonly Precondition[];
-    /** The `0x`-prefixed address of the transaction signer. */
-    readonly signer: Address;
-    /**
-     * Optional assumed token amounts for resource inputs, keyed by input name.
-     * When a materialiser resolves amounts at execution time rather than upfront,
-     * assumptions let the compiler plan routes using estimated values. The keys
-     * must match the input names declared in the flow schema.
-     */
-    readonly assumptions?: {
-        readonly [K in keyof T]?: bigint;
-    };
-    /** Optional integrator referrer identifier. */
-    readonly referrer?: string;
-    /**
-     * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
-     * A non-zero value requires the request to be authenticated with an
-     * integration-scoped API key — the integration is derived from the key, not
-     * this field. Defaults to `0` (no fee) when omitted.
-     */
-    readonly integratorFeeBps?: number;
-    /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
-    readonly maxPriceImpactBps?: number;
-    /**
-     * Destination for sweeping all proxy-held terminal resources after execution.
-     * Pass a literal `0x`-prefixed address or `{ $ref: "context.sender" }` to
-     * send remaining tokens to the signer.
-     */
-    readonly sweepTo?: SweepTo;
-    /**
-     * Controls behavior when simulation detects a revert.
-     * `'strict'` (default) returns an error; `'allow-revert'` returns a partial
-     * result with the transaction and revert diagnostics.
-     */
-    readonly simulationPolicy?: SimulationPolicy;
-    /**
-     * When `true`, the server also simulates the final user-facing transaction
-     * after the structured simulation succeeds; reverts honour
-     * `simulationPolicy`. On success the result is echoed back on the response as
-     * `userProgramSimulation`. Defaults to `false`.
-     */
-    readonly simulateUserProgram?: boolean;
-    /**
-     * When `true`, the server checks on-chain ERC-20 allowances and omits
-     * approvals that are already sufficient. Defaults to `false`.
-     */
-    readonly checkOnChainAllowances?: boolean;
+export interface ComposeRunInput<T extends InputSchema = InputSchema> {
+  /**
+   * Concrete values for each declared flow input. Resource inputs accept a
+   * materialiser or a literal integer amount; scalar inputs accept the matching type.
+   */
+  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]>; };
+  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */
+  readonly preconditions?: readonly Precondition[];
+  /** The `0x`-prefixed address of the transaction signer. */
+  readonly signer: Address;
+  /**
+   * Optional assumed token amounts for resource inputs, keyed by input name.
+   * When a materialiser resolves amounts at execution time rather than upfront,
+   * assumptions let the compiler plan routes using estimated values. The keys
+   * must match the input names declared in the flow schema.
+   */
+  readonly assumptions?: { readonly [K in keyof T]?: bigint; };
+  /** Optional integrator referrer identifier. */
+  readonly referrer?: string;
+  /**
+   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
+   * A non-zero value requires the request to be authenticated with an
+   * integration-scoped API key — the integration is derived from the key, not
+   * this field. Defaults to `0` (no fee) when omitted.
+   */
+  readonly integratorFeeBps?: number;
+  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
+  readonly maxPriceImpactBps?: number;
+  /**
+   * Destination for sweeping all proxy-held terminal resources after execution.
+   * Pass a literal `0x`-prefixed address or `{ $ref: "context.sender" }` to
+   * send remaining tokens to the signer.
+   */
+  readonly sweepTo?: SweepTo;
+  /**
+   * Controls behavior when simulation detects a revert.
+   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial
+   * result with the transaction and revert diagnostics.
+   */
+  readonly simulationPolicy?: SimulationPolicy;
+  /**
+   * When `true`, the server also simulates the final user-facing transaction
+   * after the structured simulation succeeds; reverts honour
+   * `simulationPolicy`. On success the result is echoed back on the response as
+   * `userProgramSimulation`. Defaults to `false`.
+   */
+  readonly simulateUserProgram?: boolean;
+  /**
+   * When `true`, the server checks on-chain ERC-20 allowances and omits
+   * approvals that are already sufficient. Defaults to `false`.
+   */
+  readonly checkOnChainAllowances?: boolean;
 }
 /**
  * Creates an untyped materialiser input spec. This is a low-level escape hatch
@@ -83,25 +79,25 @@ interface ComposeRunInput<T extends InputSchema = InputSchema> {
  * };
  * ```
  */
-declare const materialiser: (kind: string, config?: Record<string, unknown>) => MaterialiserInput;
+export declare const materialiser: (kind: string, config?: Record<string, unknown>) => MaterialiserInput;
 /**
  * Assembles a {@link ComposeRun} object from individual parameters.
  * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.
  *
  * @internal
  */
-declare const buildRun: (run: {
-    inputs: Record<string, InputSpec>;
-    preconditions?: readonly Precondition[];
-    signer: string;
-    assumptions?: Record<string, bigint>;
-    referrer?: string;
-    integratorFeeBps?: number;
-    maxPriceImpactBps?: number;
-    sweepTo?: SweepTo;
-    simulationPolicy?: SimulationPolicy;
-    simulateUserProgram?: boolean;
-    checkOnChainAllowances?: boolean;
+export declare const buildRun: (run: {
+  inputs: Record<string, InputSpec>;
+  preconditions?: readonly Precondition[];
+  signer: string;
+  assumptions?: Record<string, bigint>;
+  referrer?: string;
+  integratorFeeBps?: number;
+  maxPriceImpactBps?: number;
+  sweepTo?: SweepTo;
+  simulationPolicy?: SimulationPolicy;
+  simulateUserProgram?: boolean;
+  checkOnChainAllowances?: boolean;
 }) => ComposeRun;
-
-export { type ComposeRunInput, buildRun, materialiser };
+//#endregion
+//# sourceMappingURL=inputs.d.cts.map

package/dist/run/inputs.d.ts

@@ -1,67 +1,63 @@
-import { Precondition, SweepTo, SimulationPolicy, MaterialiserInput, InputSpec, ComposeRun } from '@lifi/compose-spec';
-import { InputSchema, InputSpecOf, Address } from '../types.js';
-
+import { Address, InputSchema, InputSpecOf } from "../types.js";
+import { ComposeRun, InputSpec, MaterialiserInput, Precondition, SimulationPolicy, SweepTo } from "@lifi/compose-spec";
+//#region src/run/inputs.d.ts
 /**
  * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.
  *
  * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.
  */
-interface ComposeRunInput<T extends InputSchema = InputSchema> {
-    /**
-     * Concrete values for each declared flow input. Resource inputs accept a
-     * materialiser or a literal integer amount; scalar inputs accept the matching type.
-     */
-    readonly inputs: {
-        readonly [K in keyof T]: InputSpecOf<T[K]>;
-    };
-    /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */
-    readonly preconditions?: readonly Precondition[];
-    /** The `0x`-prefixed address of the transaction signer. */
-    readonly signer: Address;
-    /**
-     * Optional assumed token amounts for resource inputs, keyed by input name.
-     * When a materialiser resolves amounts at execution time rather than upfront,
-     * assumptions let the compiler plan routes using estimated values. The keys
-     * must match the input names declared in the flow schema.
-     */
-    readonly assumptions?: {
-        readonly [K in keyof T]?: bigint;
-    };
-    /** Optional integrator referrer identifier. */
-    readonly referrer?: string;
-    /**
-     * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
-     * A non-zero value requires the request to be authenticated with an
-     * integration-scoped API key — the integration is derived from the key, not
-     * this field. Defaults to `0` (no fee) when omitted.
-     */
-    readonly integratorFeeBps?: number;
-    /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
-    readonly maxPriceImpactBps?: number;
-    /**
-     * Destination for sweeping all proxy-held terminal resources after execution.
-     * Pass a literal `0x`-prefixed address or `{ $ref: "context.sender" }` to
-     * send remaining tokens to the signer.
-     */
-    readonly sweepTo?: SweepTo;
-    /**
-     * Controls behavior when simulation detects a revert.
-     * `'strict'` (default) returns an error; `'allow-revert'` returns a partial
-     * result with the transaction and revert diagnostics.
-     */
-    readonly simulationPolicy?: SimulationPolicy;
-    /**
-     * When `true`, the server also simulates the final user-facing transaction
-     * after the structured simulation succeeds; reverts honour
-     * `simulationPolicy`. On success the result is echoed back on the response as
-     * `userProgramSimulation`. Defaults to `false`.
-     */
-    readonly simulateUserProgram?: boolean;
-    /**
-     * When `true`, the server checks on-chain ERC-20 allowances and omits
-     * approvals that are already sufficient. Defaults to `false`.
-     */
-    readonly checkOnChainAllowances?: boolean;
+export interface ComposeRunInput<T extends InputSchema = InputSchema> {
+  /**
+   * Concrete values for each declared flow input. Resource inputs accept a
+   * materialiser or a literal integer amount; scalar inputs accept the matching type.
+   */
+  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]>; };
+  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */
+  readonly preconditions?: readonly Precondition[];
+  /** The `0x`-prefixed address of the transaction signer. */
+  readonly signer: Address;
+  /**
+   * Optional assumed token amounts for resource inputs, keyed by input name.
+   * When a materialiser resolves amounts at execution time rather than upfront,
+   * assumptions let the compiler plan routes using estimated values. The keys
+   * must match the input names declared in the flow schema.
+   */
+  readonly assumptions?: { readonly [K in keyof T]?: bigint; };
+  /** Optional integrator referrer identifier. */
+  readonly referrer?: string;
+  /**
+   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).
+   * A non-zero value requires the request to be authenticated with an
+   * integration-scoped API key — the integration is derived from the key, not
+   * this field. Defaults to `0` (no fee) when omitted.
+   */
+  readonly integratorFeeBps?: number;
+  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */
+  readonly maxPriceImpactBps?: number;
+  /**
+   * Destination for sweeping all proxy-held terminal resources after execution.
+   * Pass a literal `0x`-prefixed address or `{ $ref: "context.sender" }` to
+   * send remaining tokens to the signer.
+   */
+  readonly sweepTo?: SweepTo;
+  /**
+   * Controls behavior when simulation detects a revert.
+   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial
+   * result with the transaction and revert diagnostics.
+   */
+  readonly simulationPolicy?: SimulationPolicy;
+  /**
+   * When `true`, the server also simulates the final user-facing transaction
+   * after the structured simulation succeeds; reverts honour
+   * `simulationPolicy`. On success the result is echoed back on the response as
+   * `userProgramSimulation`. Defaults to `false`.
+   */
+  readonly simulateUserProgram?: boolean;
+  /**
+   * When `true`, the server checks on-chain ERC-20 allowances and omits
+   * approvals that are already sufficient. Defaults to `false`.
+   */
+  readonly checkOnChainAllowances?: boolean;
 }
 /**
  * Creates an untyped materialiser input spec. This is a low-level escape hatch
@@ -83,25 +79,25 @@ interface ComposeRunInput<T extends InputSchema = InputSchema> {
  * };
  * ```
  */
-declare const materialiser: (kind: string, config?: Record<string, unknown>) => MaterialiserInput;
+export declare const materialiser: (kind: string, config?: Record<string, unknown>) => MaterialiserInput;
 /**
  * Assembles a {@link ComposeRun} object from individual parameters.
  * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.
  *
  * @internal
  */
-declare const buildRun: (run: {
-    inputs: Record<string, InputSpec>;
-    preconditions?: readonly Precondition[];
-    signer: string;
-    assumptions?: Record<string, bigint>;
-    referrer?: string;
-    integratorFeeBps?: number;
-    maxPriceImpactBps?: number;
-    sweepTo?: SweepTo;
-    simulationPolicy?: SimulationPolicy;
-    simulateUserProgram?: boolean;
-    checkOnChainAllowances?: boolean;
+export declare const buildRun: (run: {
+  inputs: Record<string, InputSpec>;
+  preconditions?: readonly Precondition[];
+  signer: string;
+  assumptions?: Record<string, bigint>;
+  referrer?: string;
+  integratorFeeBps?: number;
+  maxPriceImpactBps?: number;
+  sweepTo?: SweepTo;
+  simulationPolicy?: SimulationPolicy;
+  simulateUserProgram?: boolean;
+  checkOnChainAllowances?: boolean;
 }) => ComposeRun;
-
-export { type ComposeRunInput, buildRun, materialiser };
+//#endregion
+//# sourceMappingURL=inputs.d.ts.map

package/dist/run/inputs.js

@@ -1,28 +1,59 @@
+//#region src/run/inputs.ts
+/**
+* Creates an untyped materialiser input spec. This is a low-level escape hatch
+* for materialiser kinds not yet covered by the generated helpers.
+*
+* Prefer the typed helpers in the `materialisers` namespace (e.g.
+* `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide
+* compile-time config validation.
+*
+* @param kind - The materialiser type (e.g. `"balanceOf"`, `"directDeposit"`).
+* @param config - Optional materialiser-specific configuration.
+* @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.
+*
+* @example
+* ```ts
+* const run = {
+*   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },
+*   signer: '0x...',
+* };
+* ```
+*/
 const materialiser = (kind, config = {}) => ({
-  kind,
-  ...config
+	kind,
+	...config
 });
-const pickDefined = (obj) => Object.fromEntries(
-  Object.entries(obj).filter(([, value]) => value !== void 0)
-);
+/**
+* Drops the keys whose value is `undefined`, so optional fields are omitted
+* from the wire payload rather than serialized as `null`.
+*
+* A local copy of `pickDefined` from `@lifi/utils`: this package is published
+* to npm and `@lifi/utils` is a private workspace package, so it cannot be a
+* runtime dependency here.
+*/
+const pickDefined = (obj) => Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+/**
+* Assembles a {@link ComposeRun} object from individual parameters.
+* Used internally by the SDK; prefer {@link ComposeRunInput} for external use.
+*
+* @internal
+*/
 const buildRun = (run) => ({
-  inputs: run.inputs,
-  signer: run.signer,
-  ...pickDefined({
-    // An empty precondition list is the same as none, so drop it too.
-    preconditions: run.preconditions?.length ? run.preconditions : void 0,
-    assumptions: run.assumptions,
-    referrer: run.referrer,
-    integratorFeeBps: run.integratorFeeBps,
-    maxPriceImpactBps: run.maxPriceImpactBps,
-    sweepTo: run.sweepTo,
-    simulationPolicy: run.simulationPolicy,
-    simulateUserProgram: run.simulateUserProgram,
-    checkOnChainAllowances: run.checkOnChainAllowances
-  })
+	inputs: run.inputs,
+	signer: run.signer,
+	...pickDefined({
+		preconditions: run.preconditions?.length ? run.preconditions : void 0,
+		assumptions: run.assumptions,
+		referrer: run.referrer,
+		integratorFeeBps: run.integratorFeeBps,
+		maxPriceImpactBps: run.maxPriceImpactBps,
+		sweepTo: run.sweepTo,
+		simulationPolicy: run.simulationPolicy,
+		simulateUserProgram: run.simulateUserProgram,
+		checkOnChainAllowances: run.checkOnChainAllowances
+	})
 });
-export {
-  buildRun,
-  materialiser
-};
+//#endregion
+export { buildRun, materialiser };
+
 //# sourceMappingURL=inputs.js.map

package/dist/run/inputs.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    integratorFeeBps: run.integratorFeeBps,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":"AA0FO,MAAM,eAAe,CAC1B,MACA,SAAkC,CAAC,OACZ;AAAA,EACvB;AAAA,EACA,GAAG;AACL;AAUA,MAAM,cAAc,CAClB,QAEA,OAAO;AAAA,EACL,OAAO,QAAQ,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,MAAM,UAAU,MAAS;AAC/D;AAQK,MAAM,WAAW,CAAC,SAYN;AAAA,EACjB,QAAQ,IAAI;AAAA,EACZ,QAAQ,IAAI;AAAA,EACZ,GAAG,YAAY;AAAA;AAAA,IAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB;AAAA,IAC/D,aAAa,IAAI;AAAA,IACjB,UAAU,IAAI;AAAA,IACd,kBAAkB,IAAI;AAAA,IACtB,mBAAmB,IAAI;AAAA,IACvB,SAAS,IAAI;AAAA,IACb,kBAAkB,IAAI;AAAA,IACtB,qBAAqB,IAAI;AAAA,IACzB,wBAAwB,IAAI;AAAA,EAC9B,CAAC;AACH;","names":[]}
+{"version":3,"file":"inputs.js","names":[],"sources":["../../src/run/inputs.ts"],"sourcesContent":["import type {\n  ComposeRun,\n  InputSpec,\n  MaterialiserInput,\n  Precondition,\n  SimulationPolicy,\n  SweepTo,\n} from '@lifi/compose-spec';\n\nimport type { Address, InputSchema, InputSpecOf } from '../types.js';\n\n/**\n * Runtime inputs for compiling a flow. Passed to `builder.compile()` or `sdk.request()`.\n *\n * @typeParam T - The flow's input schema, used to type-check `inputs` and `assumptions`.\n */\nexport interface ComposeRunInput<T extends InputSchema = InputSchema> {\n  /**\n   * Concrete values for each declared flow input. Resource inputs accept a\n   * materialiser or a literal integer amount; scalar inputs accept the matching type.\n   */\n  readonly inputs: { readonly [K in keyof T]: InputSpecOf<T[K]> };\n  /** Optional preconditions that must hold before the flow executes (e.g. minimum balances). */\n  readonly preconditions?: readonly Precondition[];\n  /** The `0x`-prefixed address of the transaction signer. */\n  readonly signer: Address;\n  /**\n   * Optional assumed token amounts for resource inputs, keyed by input name.\n   * When a materialiser resolves amounts at execution time rather than upfront,\n   * assumptions let the compiler plan routes using estimated values. The keys\n   * must match the input names declared in the flow schema.\n   */\n  readonly assumptions?: { readonly [K in keyof T]?: bigint };\n  /** Optional integrator referrer identifier. */\n  readonly referrer?: string;\n  /**\n   * Optional integrator fee in basis points (1bp = 0.01%, max `9000` = 90%).\n   * A non-zero value requires the request to be authenticated with an\n   * integration-scoped API key — the integration is derived from the key, not\n   * this field. Defaults to `0` (no fee) when omitted.\n   */\n  readonly integratorFeeBps?: number;\n  /** Maximum acceptable price impact in basis points (e.g. `300` = 3%). */\n  readonly maxPriceImpactBps?: number;\n  /**\n   * Destination for sweeping all proxy-held terminal resources after execution.\n   * Pass a literal `0x`-prefixed address or `{ $ref: \"context.sender\" }` to\n   * send remaining tokens to the signer.\n   */\n  readonly sweepTo?: SweepTo;\n  /**\n   * Controls behavior when simulation detects a revert.\n   * `'strict'` (default) returns an error; `'allow-revert'` returns a partial\n   * result with the transaction and revert diagnostics.\n   */\n  readonly simulationPolicy?: SimulationPolicy;\n  /**\n   * When `true`, the server also simulates the final user-facing transaction\n   * after the structured simulation succeeds; reverts honour\n   * `simulationPolicy`. On success the result is echoed back on the response as\n   * `userProgramSimulation`. Defaults to `false`.\n   */\n  readonly simulateUserProgram?: boolean;\n  /**\n   * When `true`, the server checks on-chain ERC-20 allowances and omits\n   * approvals that are already sufficient. Defaults to `false`.\n   */\n  readonly checkOnChainAllowances?: boolean;\n}\n\n/**\n * Creates an untyped materialiser input spec. This is a low-level escape hatch\n * for materialiser kinds not yet covered by the generated helpers.\n *\n * Prefer the typed helpers in the `materialisers` namespace (e.g.\n * `materialisers.balanceOf()`, `materialisers.directDeposit()`) which provide\n * compile-time config validation.\n *\n * @param kind - The materialiser type (e.g. `\"balanceOf\"`, `\"directDeposit\"`).\n * @param config - Optional materialiser-specific configuration.\n * @returns A {@link MaterialiserInput} for use in {@link ComposeRunInput.inputs}.\n *\n * @example\n * ```ts\n * const run = {\n *   inputs: { token: materialiser('customKind', { myParam: '0x...' }) },\n *   signer: '0x...',\n * };\n * ```\n */\nexport const materialiser = (\n  kind: string,\n  config: Record<string, unknown> = {},\n): MaterialiserInput => ({\n  kind,\n  ...config,\n});\n\n/**\n * Drops the keys whose value is `undefined`, so optional fields are omitted\n * from the wire payload rather than serialized as `null`.\n *\n * A local copy of `pickDefined` from `@lifi/utils`: this package is published\n * to npm and `@lifi/utils` is a private workspace package, so it cannot be a\n * runtime dependency here.\n */\nconst pickDefined = <S extends Record<string, unknown>>(\n  obj: S,\n): Partial<{ [K in keyof S]: Exclude<S[K], undefined> }> =>\n  Object.fromEntries(\n    Object.entries(obj).filter(([, value]) => value !== undefined),\n  ) as Partial<{ [K in keyof S]: Exclude<S[K], undefined> }>;\n\n/**\n * Assembles a {@link ComposeRun} object from individual parameters.\n * Used internally by the SDK; prefer {@link ComposeRunInput} for external use.\n *\n * @internal\n */\nexport const buildRun = (run: {\n  inputs: Record<string, InputSpec>;\n  preconditions?: readonly Precondition[];\n  signer: string;\n  assumptions?: Record<string, bigint>;\n  referrer?: string;\n  integratorFeeBps?: number;\n  maxPriceImpactBps?: number;\n  sweepTo?: SweepTo;\n  simulationPolicy?: SimulationPolicy;\n  simulateUserProgram?: boolean;\n  checkOnChainAllowances?: boolean;\n}): ComposeRun => ({\n  inputs: run.inputs,\n  signer: run.signer,\n  ...pickDefined({\n    // An empty precondition list is the same as none, so drop it too.\n    preconditions: run.preconditions?.length ? run.preconditions : undefined,\n    assumptions: run.assumptions,\n    referrer: run.referrer,\n    integratorFeeBps: run.integratorFeeBps,\n    maxPriceImpactBps: run.maxPriceImpactBps,\n    sweepTo: run.sweepTo,\n    simulationPolicy: run.simulationPolicy,\n    simulateUserProgram: run.simulateUserProgram,\n    checkOnChainAllowances: run.checkOnChainAllowances,\n  }),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA0FA,MAAa,gBACX,MACA,SAAkC,CAAC,OACZ;CACvB;CACA,GAAG;AACL;;;;;;;;;AAUA,MAAM,eACJ,QAEA,OAAO,YACL,OAAO,QAAQ,GAAG,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAC/D;;;;;;;AAQF,MAAa,YAAY,SAYN;CACjB,QAAQ,IAAI;CACZ,QAAQ,IAAI;CACZ,GAAG,YAAY;EAEb,eAAe,IAAI,eAAe,SAAS,IAAI,gBAAgB,KAAA;EAC/D,aAAa,IAAI;EACjB,UAAU,IAAI;EACd,kBAAkB,IAAI;EACtB,mBAAmB,IAAI;EACvB,SAAS,IAAI;EACb,kBAAkB,IAAI;EACtB,qBAAqB,IAAI;EACzB,wBAAwB,IAAI;CAC9B,CAAC;AACH"}