@eco-incorp/sauce 0.99.6 → 0.99.8

package/actions/dist/abis.d.ts

@@ -9,7 +9,8 @@
  * does not have. The registry's own suite (`sdk/test/registry-abi.test.ts`) pins each of its
  * functions to the deployed contracts. Where the registry has no such function — the contract is
  * not in it, or it declares another overload — the binding declares its fragment here and says why
- * next to it.
+ * next to it. A swap at one of `@sauce/router`'s venues binds nothing here: it is a call into that
+ * library, which carries the pool and Router ABIs it calls.
  *
  * WHY OUTPUTS ARE DROPPED. A binding decodes every output its ABI declares, even one the program
  * never reads, and decoding from empty return data reverts. 3pool-era Curve pools return nothing
@@ -65,21 +66,10 @@ declare const CATALOG: {
         withdraw: BoundMethod;
         deposit: BoundMethod;
     };
-    ISwapRouter02: () => {
-        exactInputSingle: BoundMethod;
-        exactInput: BoundMethod;
-    };
-    IUniversalRouter: () => {
-        execute: BoundMethod;
-    };
-    ICurvePool: () => {
-        exchange: BoundMethod;
-    };
     ICurveRouterNG: () => {
         exchange: BoundMethod;
     };
     IBalancerV2Vault: () => {
-        swap: BoundMethod;
         batchSwap: BoundMethod;
     };
     IBalancerV3Router: () => {
@@ -92,13 +82,8 @@ declare const CATALOG: {
         userCmd: BoundMethod;
     };
     IDodoProxy: () => {
-        dodoSwapV2TokenToToken: BoundMethod;
         dodoSwapV1: BoundMethod;
     };
-    IMaverickV2Router: () => {
-        exactInputSingle: BoundMethod;
-        exactInputMultiHop: BoundMethod;
-    };
     ICarbonController: () => {
         tradeBySourceAmount: BoundMethod;
     };
@@ -148,6 +133,22 @@ declare const CATALOG: {
         quoteGasPayment: BoundMethod;
         transferRemote: BoundMethod;
     };
+    IUniswapV2Factory: () => {
+        getPair: BoundMethod;
+    };
+    IUniswapV3Factory: () => {
+        getPool: BoundMethod;
+    };
+    ISlipstreamFactory: () => {
+        getPool: BoundMethod;
+    };
+    ILBFactory: () => {
+        getLBPairInformation: BoundMethod;
+    };
+    ILBPair: () => {
+        getTokenX: BoundMethod;
+        getTokenY: BoundMethod;
+    };
     IPermit2: () => {
         approve: BoundMethod;
     };
@@ -161,7 +162,7 @@ export declare function bindingMethods(binding: BindingName): Readonly<Record<st
 export declare const BINDING_NAMES: BindingName[];
 /** The 4-byte selector of a binding's method, from the same fragment the binding compiles with. */
 export declare function methodSelector<B extends BindingName>(binding: B, method: MethodName<B>): Hex;
-/** The `contracts` map a program naming `bindings` compiles with. */
+/** The `contracts` map a program naming `bindings` compiles with — one ABI per name. */
 export declare function contractsFor(bindings: Iterable<BindingName>): ActionContracts;
 export {};
 //# sourceMappingURL=abis.d.ts.map

package/actions/dist/abis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../src/abis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAGL,KAAK,WAAW,EAEhB,KAAK,GAAG,EACT,MAAM,MAAM,CAAC;AASd,yGAAyG;AACzG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC;CAC7B;AAED,iEAAiE;AACjE,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE7D,6FAA6F;AAC7F,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,gGAAgG;AAChG,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG,MAAM,CAEnF;AAgBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,SAAS,OAAO,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,WAAW,CAgBb;AAyBD;;;;GAIG;AACH,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6OgD,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,OAAO,CAAC;AAC/C,KAAK,SAAS,CAAC,CAAC,SAAS,WAAW,IAAI,UAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,WAAW,IAAI,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAI5E,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAQ1F;AAED,uDAAuD;AACvD,eAAO,MAAM,aAAa,EAA2B,WAAW,EAAE,CAAC;AAEnE,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,CAE5F;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,eAAe,CAO7E"}
+{"version":3,"file":"abis.d.ts","sourceRoot":"","sources":["../src/abis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAGL,KAAK,WAAW,EAEhB,KAAK,GAAG,EACT,MAAM,MAAM,CAAC;AAad,yGAAyG;AACzG,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC;CAC7B;AAED,iEAAiE;AACjE,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAE7D,6FAA6F;AAC7F,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,gGAAgG;AAChG,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG,MAAM,CAEnF;AAgBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,SAAS,OAAO,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,WAAW,CAgBb;AAyBD;;;;GAIG;AACH,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwNgD,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,OAAO,CAAC;AAC/C,KAAK,SAAS,CAAC,CAAC,SAAS,WAAW,IAAI,UAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxE,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,WAAW,IAAI,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAI5E,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAQ1F;AAED,uDAAuD;AACvD,eAAO,MAAM,aAAa,EAA2B,WAAW,EAAE,CAAC;AAEnE,mGAAmG;AACnG,wBAAgB,cAAc,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,CAE5F;AAED,wFAAwF;AACxF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,eAAe,CAO7E"}

package/actions/dist/abis.js

@@ -9,7 +9,8 @@
  * does not have. The registry's own suite (`sdk/test/registry-abi.test.ts`) pins each of its
  * functions to the deployed contracts. Where the registry has no such function — the contract is
  * not in it, or it declares another overload — the binding declares its fragment here and says why
- * next to it.
+ * next to it. A swap at one of `@sauce/router`'s venues binds nothing here: it is a call into that
+ * library, which carries the pool and Router ABIs it calls.
  *
  * WHY OUTPUTS ARE DROPPED. A binding decodes every output its ABI declares, even one the program
  * never reads, and decoding from empty return data reverts. 3pool-era Curve pools return nothing
@@ -26,11 +27,10 @@
  */
 import { parseAbiItem, toFunctionSelector, } from "viem";
 import { AaveV3PoolABI, AcrossSpokePoolABI, BalancerV2VaultABI, CometABI } from "./registry.js";
-import { CrocSwapDexABI, CurveRouterNGABI, CurveThreePoolABI, DODOV2ProxyABI } from "./registry.js";
-import { ERC20ABI, LidoABI, LiquidityPoolABI, MaverickV2RouterABI } from "./registry.js";
-import { Permit2ABI, RETHABI, RocketDepositPoolABI, StargatePoolABI } from "./registry.js";
-import { TokenMessengerABI, UniswapV2RouterABI, UniswapV3SwapRouter02ABI } from "./registry.js";
-import { UniswapV4UniversalRouterABI, WstETHABI } from "./registry.js";
+import { CrocSwapDexABI, CurveRouterNGABI, ERC20ABI, LidoABI } from "./registry.js";
+import { LiquidityPoolABI, Permit2ABI, RETHABI, RocketDepositPoolABI } from "./registry.js";
+import { StargatePoolABI, TokenMessengerABI, UniswapV2RouterABI, WstETHABI } from "./registry.js";
+import { LBFactoryABI, SlipstreamCLFactoryABI, UniswapV2FactoryABI, UniswapV3FactoryABI, } from "./registry.js";
 /** The canonical `name(type,...)` signature, tuples expanded — the string a selector hashes. */
 export function canonicalSignature(fn) {
     return `${fn.name}(${fn.inputs.map(canonicalType).join(",")})`;
@@ -89,26 +89,11 @@ const CATALOG = {
         withdraw: local("function withdraw(uint256 wad)", `WETH9 is ${NOT_IN_REGISTRY}`),
         deposit: local("function deposit() payable", `WETH9 is ${NOT_IN_REGISTRY}`),
     }),
-    // Both return the amount they swapped out, which is the action's output.
-    ISwapRouter02: () => ({
-        exactInputSingle: sdk("uniswap-v3", "UniswapV3SwapRouter02ABI", UniswapV3SwapRouter02ABI, "exactInputSingle((address,address,uint24,address,uint256,uint256,uint160))", "keep"),
-        exactInput: sdk("uniswap-v3", "UniswapV3SwapRouter02ABI", UniswapV3SwapRouter02ABI, "exactInput((bytes,address,uint256,uint256))", "keep"),
-    }),
-    IUniversalRouter: () => ({
-        // The deadline-free overload: these actions carry no deadline. It returns nothing.
-        execute: sdk("uniswap-v4", "UniswapV4UniversalRouterABI", UniswapV4UniversalRouterABI, "execute(bytes,bytes[])", "drop"),
-    }),
-    ICurvePool: () => ({
-        // 3pool's `exchange` returns nothing, and a StableSwap-NG pool's `uint256` return is simply not
-        // decoded: this output-free spelling suits every 4-argument pool. The output is a balance delta.
-        exchange: sdk("curve", "CurveThreePoolABI", CurveThreePoolABI, "exchange(int128,int128,uint256,uint256)", "drop"),
-    }),
     ICurveRouterNG: () => ({
         // The six-argument overload, which takes a receiver. Its return is the amount received.
         exchange: sdk("curve", "CurveRouterNGABI", CurveRouterNGABI, "exchange(address[11],uint256[5][5],uint256,uint256,address[5],address)", "keep"),
     }),
     IBalancerV2Vault: () => ({
-        swap: sdk("balancer-v2", "BalancerV2VaultABI", BalancerV2VaultABI, "swap((bytes32,uint8,address,address,uint256,bytes),(address,bool,address,bool),uint256,uint256)", "keep"),
         // Its output is measured as a balance delta, so the `int256[]` deltas it returns are not decoded.
         batchSwap: sdk("balancer-v2", "BalancerV2VaultABI", BalancerV2VaultABI, "batchSwap(uint8,(bytes32,uint256,uint256,uint256,bytes)[],address[],(address,bool,address,bool),int256[],uint256)", "drop"),
     }),
@@ -116,21 +101,15 @@ const CATALOG = {
         swapSingleTokenExactIn: local("function swapSingleTokenExactIn(address pool, address tokenIn, address tokenOut, uint256 exactAmountIn, uint256 minAmountOut, uint256 deadline, bool wethIsEth, bytes userData) payable returns (uint256 amountOut)", `Balancer V3 is ${NOT_IN_REGISTRY}`),
     }),
     IUniswapV2Router: () => ({
-        // Fraxswap's router is UniswapV2-compatible for this function, so `fraxswapSwap` binds it too.
+        // `fraxswapSwap`'s: Fraxswap's router is UniswapV2-compatible for this function.
         swapExactTokensForTokens: sdk("uniswap-v2", "UniswapV2RouterABI", UniswapV2RouterABI, "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)", "drop"),
     }),
     ICrocSwapDex: () => ({
         userCmd: sdk("ambient", "CrocSwapDexABI", CrocSwapDexABI, "userCmd(uint16,bytes)", "drop"),
     }),
     IDodoProxy: () => ({
-        dodoSwapV2TokenToToken: sdk("dodo", "DODOV2ProxyABI", DODOV2ProxyABI, "dodoSwapV2TokenToToken(address,address,uint256,uint256,address[],uint256,bool,uint256)", "keep"),
         dodoSwapV1: local("function dodoSwapV1(address fromToken, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] dodoPairs, uint256 directions, bool isIncentive, uint256 deadLine) payable returns (uint256 returnAmount)", "the registry declares only the proxy's V2 entry point"),
     }),
-    IMaverickV2Router: () => ({
-        // The registry and the previous raw call both read the first return word as the output.
-        exactInputSingle: sdk("maverick", "MaverickV2RouterABI", MaverickV2RouterABI, "exactInputSingle(address,address,bool,uint256,uint256)", "keep"),
-        exactInputMultiHop: local("function exactInputMultiHop(address recipient, bytes path, uint256 amountIn, uint256 amountOutMinimum) payable returns (uint256 amountOut)", "the registry declares only the single-pool entry point"),
-    }),
     ICarbonController: () => ({
         tradeBySourceAmount: local("function tradeBySourceAmount(address sourceToken, address targetToken, (uint256 strategyId, uint128 amount)[] tradeActions, uint256 deadline, uint128 minReturn) payable returns (uint128)", `Carbon is ${NOT_IN_REGISTRY}`),
     }),
@@ -185,6 +164,27 @@ const CATALOG = {
             transferRemote: local("function transferRemote(uint32 destination, bytes32 recipient, uint256 amountOrId) payable", `${reason}; the message id it returns is never read`),
         };
     },
+    // A pool given by its key: the factory's lookup, called at a factory given by address. A factory
+    // given by name is called through its namespace instead, with the registry's own ABI for it.
+    IUniswapV2Factory: () => ({
+        getPair: sdk("uniswap-v2", "UniswapV2FactoryABI", UniswapV2FactoryABI, "getPair(address,address)", "keep"),
+    }),
+    IUniswapV3Factory: () => ({
+        getPool: sdk("uniswap-v3", "UniswapV3FactoryABI", UniswapV3FactoryABI, "getPool(address,address,uint24)", "keep"),
+    }),
+    ISlipstreamFactory: () => ({
+        getPool: sdk("aerodrome-slipstream", "SlipstreamCLFactoryABI", SlipstreamCLFactoryABI, "getPool(address,address,int24)", "keep"),
+    }),
+    ILBFactory: () => ({
+        getLBPairInformation: sdk("trader-joe", "LBFactoryABI", LBFactoryABI, "getLBPairInformation(address,address,uint256)", "keep"),
+    }),
+    ILBPair: () => {
+        const reason = "the registry carries Trader Joe's router and factory, not the LB pair";
+        return {
+            getTokenX: local("function getTokenX() view returns (address tokenX)", reason),
+            getTokenY: local("function getTokenY() view returns (address tokenY)", reason),
+        };
+    },
     IPermit2: () => ({
         approve: sdk("permit2", "Permit2ABI", Permit2ABI, "approve(address,address,uint160,uint48)", "drop"),
     }),
@@ -205,7 +205,7 @@ export const BINDING_NAMES = Object.keys(CATALOG);
 export function methodSelector(binding, method) {
     return toFunctionSelector(bindingMethods(binding)[method].fn);
 }
-/** The `contracts` map a program naming `bindings` compiles with. */
+/** The `contracts` map a program naming `bindings` compiles with — one ABI per name. */
 export function contractsFor(bindings) {
     const out = {};
     for (const binding of [...new Set(bindings)].sort()) {

package/actions/dist/compile.d.ts

@@ -3,10 +3,10 @@
  * compile shares the SDK's wasm instance and its `ready()`: in a browser, `await ready()` from
  * `@eco-incorp/sauce` or `@eco-incorp/sauce/compiler` once, and every compile here works.
  *
- * A generated program imports no module: its ABI bindings are handed to the compiler in memory as
- * `inlineContracts`, so the resolver only ever serves the entry — no caller modules, no
- * `resolvePackage`. That is why this is not the SDK's `routes/rs-compile.ts`, which also resolves
- * the SDK's own stdlib and a caller's files.
+ * A generated program's ABI bindings are handed to the compiler in memory as `inlineContracts`. The
+ * one module it may import is `@sauce/router`, for a swap at one of that library's venues, and the
+ * SDK serves it — and the `@sauce/token` and pool ABIs it imports in turn — from memory
+ * (`resolveSdkPackage`, `resolveSdkModule`), so no caller resolver and no filesystem is involved.
  */
 import type { CompileResult } from "sauce-compiler";
 import type { ActionContracts } from "./abis.js";

package/actions/dist/compile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAIjD,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,eAAoB,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CAaf"}
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAKpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAKjD,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,eAAoB,EAC/B,OAAO,GAAE,iBAAsB,GAC9B,aAAa,CAcf"}

package/actions/dist/compile.js

@@ -1,6 +1,7 @@
 // By relative path into the SDK's build, like `registry.ts`: in the published tarball `actions/dist`
 // and `sdk/dist` are siblings.
 import { compile } from "../../sdk/dist/wasm-compiler.js";
+import { resolveSdkModule, resolveSdkPackage } from "./registry.js";
 const ENTRY = "main.js";
 /** Compiles a generated SauceScript program, and the ABI bindings it names, for the EVM. */
 export function compileEvm(source, contracts = {}, options = {}) {
@@ -9,7 +10,8 @@ export function compileEvm(source, contracts = {}, options = {}) {
     return compile({
         target: "evm",
         entry: ENTRY,
-        resolve: (path) => (path === ENTRY ? bytes : undefined),
+        resolve: (path) => (path === ENTRY ? bytes : resolveSdkModule(path)),
+        resolvePackage: (specifier) => resolveSdkPackage(specifier),
         inlineContracts: inlineContracts.length > 0 ? inlineContracts : undefined,
         compactArgs: options.compactArgs,
     });

package/actions/dist/compose.d.ts

@@ -1,7 +1,16 @@
+import { type CanonicalChain, type ChainRef } from "../../sdk/dist/chains/canonical.js";
 import { type IntentOptions, type PendingSauceRoute } from "../../sdk/dist/routes/index.js";
 import type { ActionContracts } from "./abis.js";
+import { type Lowered } from "./to-sauce.js";
 import type { ActionProgram } from "./types.js";
 export interface CompileOptions {
+    /**
+     * The chain to compile for — a slug (`"base"`), a chain id (`8453`) or a canonical chain — whose
+     * names the program's token symbols and namespace references resolve to. Defaults to the
+     * document's `chainId`; a document without one needs it, and one with a `chainId` compiles for
+     * that chain only.
+     */
+    readonly chain?: ChainRef;
     /** Encode the runtime arguments compact-v1 instead of ABI-v1. Default `false`. */
     readonly compactArgs?: boolean;
 }
@@ -16,8 +25,13 @@ export interface ArgumentEncoding {
 }
 export interface CompiledProgram {
     readonly bytecode: Uint8Array;
-    /** The SauceScript that was compiled. */
+    /**
+     * The SauceScript the actions lowered to, with every name as written — `USDC`,
+     * `UniswapV3.Factory.getPool(...)` — which the compile resolved on its chain.
+     */
     readonly source: string;
+    /** The ABI bindings `source` calls through (`IErc20`, `IAaveV3Pool`), handed to its compile. */
+    readonly contracts: ActionContracts;
     /** The `argument` names, in the order `main` takes them. Empty when there are none. */
     readonly parameters: readonly string[];
     readonly entryEncoding: "abi-v1" | "compact-v1";
@@ -32,15 +46,58 @@ export interface CompiledProgram {
      */
     argumentOffset(name: string, encoding?: ArgumentEncoding): number;
 }
-/** Compiles an action program standalone. Its `argument` actions become runtime arguments. */
+/** An action program checked for one chain and lowered: what both compiles start from. */
+export interface LoweredProgram {
+    readonly chain: CanonicalChain;
+    /** The program as parsed: canonical, every name as written. */
+    readonly program: ActionProgram;
+    readonly lowered: Lowered;
+}
+/**
+ * Parses `program`, checks every name it uses — and the rules its resolved addresses must keep
+ * (no swap of a token for itself, a chain's native-coin rules) — on the chain it compiles for, and
+ * lowers it. Throws a `ProgramError` listing every problem with its path.
+ */
+export declare function lowerProgram(program: ActionProgram, chain?: ChainRef): LoweredProgram;
+/** An action program as the SauceScript it lowers to on one chain: what `sauce actions` prints. */
+export interface ProgramSource {
+    readonly chain: CanonicalChain;
+    /** The document as parsed: canonical, every name as written. */
+    readonly program: ActionProgram;
+    /** A standalone program, `main`'s parameters typed — the source `compileProgram` compiles. */
+    readonly source: string;
+    /** The ABI bindings `source` calls through, which its compile takes as `contracts`. */
+    readonly contracts: ActionContracts;
+    /** The `argument` names, in the order `main` takes them. */
+    readonly parameters: readonly string[];
+}
+/**
+ * The SauceScript an action program lowers to for `chain` (else its `chainId`), checked there but
+ * not compiled: with `contracts`, `routes.compileSauceProgram(chain, source, { contracts })`
+ * compiles it to the bytes `compileProgram` returns. The `sauce` command's `actions` reads this,
+ * and hands the source to the compile and cook every other program goes through.
+ */
+export declare function programSource(program: ActionProgram, chain?: ChainRef): ProgramSource;
+/**
+ * Compiles an action program standalone, for `options.chain` or its own `chainId`. Its `argument`
+ * actions become runtime arguments.
+ */
 export declare function compileProgram(program: ActionProgram, options?: CompileOptions): CompiledProgram;
-/** Compiles generated source into a `CompiledProgram`. */
-export declare function compiled(source: string, contracts: ActionContracts, parameters: readonly string[], options?: CompileOptions): CompiledProgram;
 /**
- * An action program as an Eco intent route on the program's own chain:
+ * Compiles generated source into a `CompiledProgram`: for `chain` with its names, through the SDK's
+ * program compile, or — a split swap with no chain, whose source holds only addresses — directly.
+ */
+export declare function compiled(source: string, contracts: ActionContracts, parameters: readonly string[], options?: CompileOptions, chain?: CanonicalChain): CompiledProgram;
+/** `programIntent`'s options: an intent's, and the chain its route runs on. */
+export type ProgramIntentOptions = IntentOptions & {
+    /** The route's chain, whose names the program resolves; defaults to the document's `chainId`. */
+    readonly chain?: ChainRef;
+};
+/**
+ * An action program as an Eco intent route on its chain (`options.chain`, else its `chainId`):
  * `programIntent(program, options).reward(reward)` is `Base(body, options).reward(reward)` with the
  * program as the body. Moving value to another chain is a bridge action inside the program, or a
  * nested intent (`.nest(...)`) on the returned route.
  */
-export declare function programIntent(program: ActionProgram, options: IntentOptions): PendingSauceRoute;
+export declare function programIntent(program: ActionProgram, options: ProgramIntentOptions): PendingSauceRoute;
 //# sourceMappingURL=compose.d.ts.map

package/actions/dist/compose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAkBA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EAEvB,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAIjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,sEAAsE;AACtE,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;AAEhF,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAC9B,yCAAyC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,QAAQ,GAAG,YAAY,CAAC;IAChD,kEAAkE;IAClE,QAAQ,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC;IAClC,0GAA0G;IAC1G,OAAO,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,UAAU,CAAC;IAC1E;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;CACnE;AAED,8FAA8F;AAC9F,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,cAAmB,GAC3B,eAAe,CAIjB;AAED,0DAA0D;AAC1D,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,eAAe,EAC1B,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,GAAE,cAAmB,GAC3B,eAAe,CAmEjB;AA8BD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,GAAG,iBAAiB,CAQ/F"}
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"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"}

package/actions/dist/compose.js

@@ -7,26 +7,109 @@
  * declared `scalarWidth` each sits at a fixed offset (`argumentOffset`), which is what lets a caller
  * splice a number measured at runtime into an otherwise precompiled payload.
  *
- * INTENT (`programIntent`). The program is the route body on its own chain: the SDK compiles it
- * there, puts its cook in the route, and `.reward(...)` / `.nest(...)` work on it like on any other.
- * A route body takes no runtime arguments, so an amount only known at execution comes from a
+ * INTENT (`programIntent`). The program is the route body on its chain: the SDK compiles it there,
+ * puts its cook in the route, and `.reward(...)` / `.nest(...)` work on it like on any other. A
+ * route body takes no runtime arguments, so an amount only known at execution comes from a
  * `balanceOf` action instead — which is also how a child of a dynamic `.nest()` spends exactly what
  * its parent delivered.
+ *
+ * THE CHAIN. Both compile for one chain: `options.chain`, else the document's `chainId`. The
+ * program's token symbols and namespace references are its globals, and that compile resolves them
+ * there — the SDK's own program compile, `routes.compileSauceProgram`, with the chain's names — so
+ * a document with no `chainId` compiles for any chain where its names exist. A name the chain lacks
+ * is refused first, with its path (`names.ts`).
  */
 import { concatBytes, encodeAbiParameters, hexToBytes } from "viem";
+import { resolveChain, } from "../../sdk/dist/chains/canonical.js";
 import { encodeCompactArguments } from "../../sdk/dist/compact-arguments.js";
-import { openRoute, } from "../../sdk/dist/routes/index.js";
+import { compileSauceProgram, openRoute, } from "../../sdk/dist/routes/index.js";
 import { compileEvm } from "./compile.js";
+import { chainLabel, resolveNames, wrappedNativeIssues } from "./names.js";
 import { parseProgram } from "./program.js";
+import { ProgramError, programIssues } from "./semantics.js";
 import { lowerActions, renderProgram, renderRouteBody } from "./to-sauce.js";
-/** Compiles an action program standalone. Its `argument` actions become runtime arguments. */
+/**
+ * The chain a document compiles for: `given`, else its own `chainId`. A document with a `chainId`
+ * compiles for that chain alone — its addresses are that chain's.
+ */
+function targetChain(documentChain, given) {
+    const ref = given ?? documentChain;
+    if (ref === undefined) {
+        throw new Error("the action program has no `chainId`, so say which chain to compile it for: pass `chain` " +
+            '(a slug such as "base", or a chain id). A document that names its tokens and ' +
+            "contracts compiles for any chain where they exist.");
+    }
+    const chain = resolveChain(ref);
+    if (chain === undefined) {
+        throw new Error(`unknown chain ${JSON.stringify(String(ref))}: the program's names resolve against one of ` +
+            'the SDK\'s canonical chains (a slug such as "base", or its chain id)');
+    }
+    if (chain.kind !== "evm") {
+        throw new Error(`action programs run on EVM chains; ${chain.slug} is ${chain.kind}`);
+    }
+    if (documentChain !== undefined && chain.id !== documentChain) {
+        throw new ProgramError([
+            {
+                path: "chainId",
+                message: `the program is written for chain ${documentChain}, not ${chainLabel(chain)}: its ` +
+                    "addresses are that chain's. Leave `chainId` out to compile it for other chains — " +
+                    "with every token and contract named, it compiles for any chain that has them",
+            },
+        ]);
+    }
+    return chain;
+}
+/**
+ * Parses `program`, checks every name it uses — and the rules its resolved addresses must keep
+ * (no swap of a token for itself, a chain's native-coin rules) — on the chain it compiles for, and
+ * lowers it. Throws a `ProgramError` listing every problem with its path.
+ */
+export function lowerProgram(program, chain) {
+    const parsed = parseProgram(program);
+    const target = targetChain(parsed.chainId, chain);
+    const { resolved, issues } = resolveNames(parsed.actions, target);
+    issues.push(...wrappedNativeIssues(parsed.actions, target));
+    if (issues.length === 0)
+        issues.push(...programIssues(resolved, target.id));
+    if (issues.length > 0)
+        throw new ProgramError(issues, target);
+    return { chain: target, program: parsed, lowered: lowerActions(parsed.actions) };
+}
+/**
+ * The SauceScript an action program lowers to for `chain` (else its `chainId`), checked there but
+ * not compiled: with `contracts`, `routes.compileSauceProgram(chain, source, { contracts })`
+ * compiles it to the bytes `compileProgram` returns. The `sauce` command's `actions` reads this,
+ * and hands the source to the compile and cook every other program goes through.
+ */
+export function programSource(program, chain) {
+    const lowered = lowerProgram(program, chain);
+    return {
+        chain: lowered.chain,
+        program: lowered.program,
+        source: renderProgram(lowered.lowered),
+        contracts: lowered.lowered.contracts,
+        parameters: lowered.lowered.parameters,
+    };
+}
+/**
+ * Compiles an action program standalone, for `options.chain` or its own `chainId`. Its `argument`
+ * actions become runtime arguments.
+ */
 export function compileProgram(program, options = {}) {
-    const lowered = lowerActions(parseProgram(program).actions);
-    return compiled(renderProgram(lowered), lowered.contracts, lowered.parameters, options);
+    const { chain, lowered } = lowerProgram(program, options.chain);
+    return compiled(renderProgram(lowered), lowered.contracts, lowered.parameters, options, chain);
 }
-/** Compiles generated source into a `CompiledProgram`. */
-export function compiled(source, contracts, parameters, options = {}) {
-    const result = compileEvm(source, contracts, { compactArgs: options.compactArgs });
+/**
+ * Compiles generated source into a `CompiledProgram`: for `chain` with its names, through the SDK's
+ * program compile, or — a split swap with no chain, whose source holds only addresses — directly.
+ */
+export function compiled(source, contracts, parameters, options = {}, chain) {
+    const result = chain === undefined
+        ? compileEvm(source, contracts, { compactArgs: options.compactArgs })
+        : compileSauceProgram(chain, source, {
+            contracts: contracts,
+            ...(options.compactArgs === true ? { compactArgs: true } : {}),
+        });
     const { bytecode } = result;
     const positional = (values = {}) => {
         const unknown = Object.keys(values).filter((name) => !parameters.includes(name));
@@ -62,6 +145,7 @@ export function compiled(source, contracts, parameters, options = {}) {
     return {
         bytecode,
         source,
+        contracts,
         parameters,
         entryEncoding: result.entryEncoding,
         entrySchema: result.entrySchema,
@@ -103,16 +187,16 @@ function withContracts(compile, contracts) {
     };
 }
 /**
- * An action program as an Eco intent route on the program's own chain:
+ * An action program as an Eco intent route on its chain (`options.chain`, else its `chainId`):
  * `programIntent(program, options).reward(reward)` is `Base(body, options).reward(reward)` with the
  * program as the body. Moving value to another chain is a bridge action inside the program, or a
  * nested intent (`.nest(...)`) on the returned route.
  */
 export function programIntent(program, options) {
-    const { chainId, actions } = parseProgram(program);
-    const lowered = lowerActions(actions);
-    return openRoute(chainId, renderRouteBody(lowered), {
-        ...options,
-        compile: withContracts(options.compile, lowered.contracts),
+    const { chain: given, ...intent } = options;
+    const { chain, lowered } = lowerProgram(program, given);
+    return openRoute(chain, renderRouteBody(lowered), {
+        ...intent,
+        compile: withContracts(intent.compile, lowered.contracts),
     });
 }

package/actions/dist/index.d.ts

@@ -4,7 +4,7 @@ export type { ProgramIssue } from "./semantics.js";
 export { programSchema } from "./schema.js";
 export type { JsonSchema } from "./schema.js";
 export { compileProgram, programIntent } from "./compose.js";
-export type { ArgumentEncoding, ArgumentValues, CompiledProgram, CompileOptions, } from "./compose.js";
+export type { ArgumentEncoding, ArgumentValues, CompiledProgram, CompileOptions, ProgramIntentOptions, } from "./compose.js";
 export { quoteAction } from "./to-quote.js";
 export type { Quote, QuoteOptions } from "./to-quote.js";
 export { compileSplitSwap } from "./split-swap.js";

package/actions/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7D,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,cAAc,GACf,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,mBAAmB,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7D,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,cAAc,EACd,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,mBAAmB,YAAY,CAAC"}

package/actions/dist/names.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Tokens and protocol contracts by name, as a Sauce program names them.
+ *
+ * A token field takes a registry symbol (`"USDC"`) and a contract field a namespace reference
+ * (`"UniswapV3.Factory"`), beside an address. The generated program carries the NAME — the program
+ * global it is — so the compile for a chain resolves it there, exactly as a hand-written program's
+ * `USDC` resolves: an action document that names everything is chain-agnostic. This module is the
+ * check made first, on the chain being compiled for, so a name that chain lacks is reported with
+ * its path, the chain and the name, rather than as the compiler's "not a declared variable".
+ *
+ * The names come from `routes.sourceGlobals(chain)` — the SDK's own list of what a program compiled
+ * for the chain may use, read from the same registries the compile reads — never a second table.
+ * The same pass also yields each name's address, for the checks that compare tokens (a swap of a
+ * token for itself) and for the quote calls, which are built here rather than compiled.
+ */
+import { type CanonicalChain } from "../../sdk/dist/chains/canonical.js";
+import type { ProgramIssue } from "./semantics.js";
+import type { Action } from "./types.js";
+/** A registry token symbol: the registry's own ticker rule (`token-registry.ts`). */
+export declare const TOKEN_SYMBOL_RE: RegExp;
+/**
+ * The shape of a symbol, stocks' included: an identifier with a capital letter in it, as an
+ * issuer's ticker is ("SPCXc", "TSLAon", "bTSLA", "BRK_Bx") and `"native"` and `"usdc"` are not.
+ * What the JSON Schema accepts, since it lists no names; the parser takes only the uppercase
+ * ticker shape and the stock symbols the registry has (`isTokenSymbol`).
+ */
+export declare const STOCK_SYMBOL_RE: RegExp;
+/** True for a token symbol: the uppercase ticker shape, or a tokenized stock's own symbol. */
+export declare function isTokenSymbol(value: string): boolean;
+/** The registry's spelling of `value` written in another case (`spcxc` is `SPCXc`), if any. */
+export declare function registrySpelling(value: string): string | undefined;
+/** A protocol contract by namespace: `Namespace.Contract`, as a program writes it. */
+export declare const CONTRACT_NAME_RE: RegExp;
+/** The native currency, where a venue trades it itself: the zero address it keys it as. */
+export declare const NATIVE = "native";
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+type Address = `0x${string}`;
+/** True for a token symbol or a namespace reference — anything but an address or `"native"`. */
+export declare function isName(value: string): boolean;
+/** A contract a program can name on one chain. */
+interface NamedContract {
+    readonly address: Address;
+    /** Its methods' canonical signatures, as the registry declares them. */
+    readonly signatures: ReadonlySet<string>;
+}
+/** What a program compiled for one chain can name. */
+interface ChainNames {
+    readonly chain: CanonicalChain;
+    readonly tokens: ReadonlyMap<string, Address>;
+    /** Its tokenized stocks' symbols, which a refusal counts rather than lists. */
+    readonly stocks: ReadonlySet<string>;
+    /** `Namespace.Contract` -> the contract. */
+    readonly contracts: ReadonlyMap<string, NamedContract>;
+    /** Namespace -> its contracts on this chain. */
+    readonly namespaces: ReadonlyMap<string, readonly string[]>;
+}
+/** The names a program compiled for `chain` resolves, from `routes.sourceGlobals`. */
+export declare function chainNames(chain: CanonicalChain): ChainNames;
+/** `Base (base, chain 8453)`. */
+export declare function chainLabel(chain: CanonicalChain): string;
+/**
+ * The method a pool key reads from its factory, by action and key: what a `factory` given by name
+ * must declare, so a factory of the wrong kind is refused before it is called.
+ */
+export declare function poolLookup(action: Action): {
+    readonly signature: string;
+    readonly kind: string;
+} | undefined;
+/**
+ * Every name in `actions` checked on `chain`: the issues for the ones it lacks, each with its path,
+ * and a copy of the actions with every name replaced by its address on that chain.
+ */
+export declare function resolveNames(actions: readonly Action[], chain: CanonicalChain, path?: string): {
+    readonly resolved: Action[];
+    readonly issues: ProgramIssue[];
+};
+/**
+ * A name whose MEANING depends on the chain, refused where it means something else: `"WETH"` is
+ * the wrapped native coin only where the native coin is ETH. On Polygon the registry's WETH is
+ * bridged ETH beside the native POL, so a `wrapETH` or `unwrapETH` of `"WETH"` there would call a
+ * token that wraps nothing. (Arc, whose native coin is itself an ERC-20, refuses wrapping outright:
+ * `semantics.ts`.) An address is taken as given: it says which contract is meant.
+ */
+export declare function wrappedNativeIssues(actions: readonly Action[], chain: CanonicalChain, path?: string): ProgramIssue[];
+/** True when any action names a token or a contract rather than giving its address. */
+export declare function usesNames(actions: readonly Action[]): boolean;
+export {};
+//# sourceMappingURL=names.d.ts.map

package/actions/dist/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../src/names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAM3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,qFAAqF;AACrF,eAAO,MAAM,eAAe,QAA0B,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,QAAiD,CAAC;AAgB9E,8FAA8F;AAC9F,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,+FAA+F;AAC/F,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQlE;AAED,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,QAA8C,CAAC;AAE5E,2FAA2F;AAC3F,eAAO,MAAM,MAAM,WAAW,CAAC;AAE/B,eAAO,MAAM,YAAY,+CAA+C,CAAC;AAEzE,KAAK,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAE7B,gGAAgG;AAChG,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,kDAAkD;AAClD,UAAU,aAAa;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC1C;AAED,sDAAsD;AACtD,UAAU,UAAU;IAClB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACvD,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;CAC7D;AAID,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CA6B5D;AAmBD,iCAAiC;AACjC,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAExD;AAwJD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAqBnE;AA0BD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,cAAc,EACrB,IAAI,SAAY,GACf;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,CAclE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,cAAc,EACrB,IAAI,SAAY,GACf,YAAY,EAAE,CAiBhB;AAED,uFAAuF;AACvF,wBAAgB,SAAS,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAoB7D"}